diff --git a/pdata/internal/cmd/pdatagen/internal/base_fields.go b/pdata/internal/cmd/pdatagen/internal/base_fields.go index 7808e6b9820..cdfcd0a3b13 100644 --- a/pdata/internal/cmd/pdatagen/internal/base_fields.go +++ b/pdata/internal/cmd/pdatagen/internal/base_fields.go @@ -329,8 +329,8 @@ func (sf *sliceField) templateFields(ms *messageValueStruct) map[string]any { return "" }(), "returnType": sf.returnSlice.getName(), - "origAccessor": origAccessor(ms), - "stateAccessor": stateAccessor(ms), + "origAccessor": origAccessor(ms.packageName), + "stateAccessor": stateAccessor(ms.packageName), "isCommon": usedByOtherDataTypes(sf.returnSlice.getPackageName()), "isBaseStructCommon": usedByOtherDataTypes(ms.packageName), "originFieldName": func() string { @@ -394,8 +394,8 @@ func (mf *messageValueField) templateFields(ms *messageValueStruct) map[string]a } return "" }(), - "origAccessor": origAccessor(ms), - "stateAccessor": stateAccessor(ms), + "origAccessor": origAccessor(ms.packageName), + "stateAccessor": stateAccessor(ms.packageName), } } @@ -448,8 +448,8 @@ func (pf *primitiveField) templateFields(ms *messageValueStruct) map[string]any "lowerFieldName": strings.ToLower(pf.fieldName), "testValue": pf.testVal, "returnType": pf.returnType, - "origAccessor": origAccessor(ms), - "stateAccessor": stateAccessor(ms), + "origAccessor": origAccessor(ms.packageName), + "stateAccessor": stateAccessor(ms.packageName), "originStructName": ms.originFullName, "originFieldName": func() string { if pf.originFieldName == "" { @@ -583,8 +583,8 @@ func (psf *primitiveSliceField) templateFields(ms *messageValueStruct) map[strin "fieldName": psf.fieldName, "lowerFieldName": strings.ToLower(psf.fieldName), "testValue": psf.testVal, - "origAccessor": origAccessor(ms), - "stateAccessor": stateAccessor(ms), + "origAccessor": origAccessor(ms.packageName), + "stateAccessor": stateAccessor(ms.packageName), } } @@ -647,8 +647,8 @@ func (of *oneOfField) templateFields(ms *messageValueStruct) map[string]any { "typeName": of.typeName, "originFieldName": of.originFieldName, "lowerOriginFieldName": strings.ToLower(of.originFieldName), - "origAccessor": origAccessor(ms), - "stateAccessor": stateAccessor(ms), + "origAccessor": origAccessor(ms.packageName), + "stateAccessor": stateAccessor(ms.packageName), "values": of.values, "originTypePrefix": ms.originFullName + "_", } @@ -846,15 +846,15 @@ func (opv *optionalPrimitiveValue) templateFields(ms *messageValueStruct) map[st var _ baseField = (*optionalPrimitiveValue)(nil) -func origAccessor(bs *messageValueStruct) string { - if usedByOtherDataTypes(bs.packageName) { +func origAccessor(packageName string) string { + if usedByOtherDataTypes(packageName) { return "getOrig()" } return "orig" } -func stateAccessor(bs *messageValueStruct) string { - if usedByOtherDataTypes(bs.packageName) { +func stateAccessor(packageName string) string { + if usedByOtherDataTypes(packageName) { return "getState()" } return "state" diff --git a/pdata/internal/cmd/pdatagen/internal/base_slices.go b/pdata/internal/cmd/pdatagen/internal/base_slices.go index 24c648de9f2..f937550b4aa 100644 --- a/pdata/internal/cmd/pdatagen/internal/base_slices.go +++ b/pdata/internal/cmd/pdatagen/internal/base_slices.go @@ -44,22 +44,31 @@ func (ss *sliceOfPtrs) generateTests(packageInfo *PackageInfo) []byte { } func (ss *sliceOfPtrs) templateFields(packageInfo *PackageInfo) map[string]any { + orig := origAccessor(ss.packageName) + state := stateAccessor(ss.packageName) return map[string]any{ "type": "sliceOfPtrs", + "isCommon": usedByOtherDataTypes(ss.packageName), "structName": ss.structName, "elementName": ss.element.structName, "originName": ss.element.originFullName, "originElementType": "*" + ss.element.originFullName, "emptyOriginElement": "&" + ss.element.originFullName + "{}", - "newElement": "new" + ss.element.structName + "((*es.orig)[i], es.state)", + "newElement": "new" + ss.element.structName + "((*es." + orig + ")[i], es." + state + ")", + "origAccessor": orig, + "stateAccessor": state, "packageName": packageInfo.name, "imports": packageInfo.imports, "testImports": packageInfo.testImports, } } -func (ss *sliceOfPtrs) generateInternal(*PackageInfo) []byte { - return nil +func (ss *sliceOfPtrs) generateInternal(packageInfo *PackageInfo) []byte { + var sb bytes.Buffer + if err := sliceInternalTemplate.Execute(&sb, ss.templateFields(packageInfo)); err != nil { + panic(err) + } + return sb.Bytes() } var _ baseStruct = (*sliceOfPtrs)(nil) @@ -96,6 +105,8 @@ func (ss *sliceOfValues) generateTests(packageInfo *PackageInfo) []byte { } func (ss *sliceOfValues) templateFields(packageInfo *PackageInfo) map[string]any { + orig := origAccessor(ss.packageName) + state := stateAccessor(ss.packageName) return map[string]any{ "type": "sliceOfValues", "structName": ss.structName, @@ -103,15 +114,21 @@ func (ss *sliceOfValues) templateFields(packageInfo *PackageInfo) map[string]any "originName": ss.element.originFullName, "originElementType": ss.element.originFullName, "emptyOriginElement": ss.element.originFullName + "{}", - "newElement": "new" + ss.element.structName + "(&(*es.orig)[i], es.state)", + "newElement": "new" + ss.element.structName + "(&(*es." + orig + ")[i], es." + state + ")", + "origAccessor": orig, + "stateAccessor": state, "packageName": packageInfo.name, "imports": packageInfo.imports, "testImports": packageInfo.testImports, } } -func (ss *sliceOfValues) generateInternal(*PackageInfo) []byte { - return nil +func (ss *sliceOfValues) generateInternal(packageInfo *PackageInfo) []byte { + var sb bytes.Buffer + if err := sliceInternalTemplate.Execute(&sb, ss.templateFields(packageInfo)); err != nil { + panic(err) + } + return sb.Bytes() } var _ baseStruct = (*sliceOfValues)(nil) diff --git a/pdata/internal/cmd/pdatagen/internal/base_structs.go b/pdata/internal/cmd/pdatagen/internal/base_structs.go index 4cd7832f12d..74dc95d1fca 100644 --- a/pdata/internal/cmd/pdatagen/internal/base_structs.go +++ b/pdata/internal/cmd/pdatagen/internal/base_structs.go @@ -58,18 +58,13 @@ func (ms *messageValueStruct) templateFields(packageInfo *PackageInfo) map[strin "fields": ms.fields, "structName": ms.structName, "originName": ms.originFullName, - "generateTestData": func() string { - if usedByOtherDataTypes(ms.packageName) { - return ms.structName + "(internal.GenerateTest" + ms.structName + "())" - } - return "generateTest" + ms.structName + "()" - }(), - "description": ms.description, - "isCommon": usedByOtherDataTypes(ms.packageName), - "origAccessor": origAccessor(ms), - "packageName": packageInfo.name, - "imports": packageInfo.imports, - "testImports": packageInfo.testImports, + "description": ms.description, + "isCommon": usedByOtherDataTypes(ms.packageName), + "origAccessor": origAccessor(ms.packageName), + "stateAccessor": stateAccessor(ms.packageName), + "packageName": packageInfo.name, + "imports": packageInfo.imports, + "testImports": packageInfo.testImports, } } diff --git a/pdata/internal/cmd/pdatagen/internal/templates.go b/pdata/internal/cmd/pdatagen/internal/templates.go index e7218752979..5441d39bbe8 100644 --- a/pdata/internal/cmd/pdatagen/internal/templates.go +++ b/pdata/internal/cmd/pdatagen/internal/templates.go @@ -37,6 +37,10 @@ var ( sliceTemplateBytes []byte sliceTemplate = parseTemplate("slice.go", sliceTemplateBytes) + //go:embed templates/slice_internal.go.tmpl + sliceInternalTemplateBytes []byte + sliceInternalTemplate = parseTemplate("slice_internal.go", sliceInternalTemplateBytes) + //go:embed templates/slice_test.go.tmpl sliceTestTemplateBytes []byte sliceTestTemplate = parseTemplate("slice_test.go", sliceTestTemplateBytes) diff --git a/pdata/internal/cmd/pdatagen/internal/templates/message.go.tmpl b/pdata/internal/cmd/pdatagen/internal/templates/message.go.tmpl index d7e93b9f31d..b6486fbe48a 100644 --- a/pdata/internal/cmd/pdatagen/internal/templates/message.go.tmpl +++ b/pdata/internal/cmd/pdatagen/internal/templates/message.go.tmpl @@ -48,8 +48,8 @@ func New{{ .structName }}() {{ .structName }} { // MoveTo moves all properties from the current struct overriding the destination and // resetting the current instance to its zero value func (ms {{ .structName }}) MoveTo(dest {{ .structName }}) { - ms.{{- if .isCommon }}getState(){{ else }}state{{ end }}.AssertMutable() - dest.{{- if .isCommon }}getState(){{ else }}state{{ end }}.AssertMutable() + ms.{{ .stateAccessor }}.AssertMutable() + dest.{{ .stateAccessor }}.AssertMutable() *dest.{{ .origAccessor }} = *ms.{{ .origAccessor }} *ms.{{ .origAccessor }} = {{ .originName }}{} } @@ -70,7 +70,7 @@ func (ms {{ .structName }}) getState() *internal.State { // CopyTo copies all properties from the current struct overriding the destination. func (ms {{ .structName }}) CopyTo(dest {{ .structName }}) { - dest.{{- if .isCommon }}getState(){{ else }}state{{ end }}.AssertMutable() + dest.{{ .stateAccessor }}.AssertMutable() {{- range .fields }} {{ .GenerateCopyToValue $.messageStruct }} {{- end }} diff --git a/pdata/internal/cmd/pdatagen/internal/templates/message_test.go.tmpl b/pdata/internal/cmd/pdatagen/internal/templates/message_test.go.tmpl index ff96aa71718..2c78569b158 100644 --- a/pdata/internal/cmd/pdatagen/internal/templates/message_test.go.tmpl +++ b/pdata/internal/cmd/pdatagen/internal/templates/message_test.go.tmpl @@ -13,11 +13,11 @@ import ( ) func Test{{ .structName }}_MoveTo(t *testing.T) { - ms := {{ .generateTestData }} + ms := generateTest{{ .structName }}() dest := New{{ .structName }}() ms.MoveTo(dest) assert.Equal(t, New{{ .structName }}(), ms) - assert.Equal(t, {{ .generateTestData }}, dest) + assert.Equal(t, generateTest{{ .structName }}(), dest) sharedState := internal.StateReadOnly assert.Panics(t, func() { ms.MoveTo(new{{ .structName }}(&{{ .originName }}{}, &sharedState)) }) assert.Panics(t, func() { new{{ .structName }}(&{{ .originName }}{}, &sharedState).MoveTo(dest) }) @@ -28,7 +28,7 @@ func Test{{ .structName }}_CopyTo(t *testing.T) { orig := New{{ .structName }}() orig.CopyTo(ms) assert.Equal(t, orig, ms) - orig = {{ .generateTestData }} + orig = generateTest{{ .structName }}() orig.CopyTo(ms) assert.Equal(t, orig, ms) sharedState := internal.StateReadOnly @@ -39,13 +39,17 @@ func Test{{ .structName }}_CopyTo(t *testing.T) { {{ .GenerateAccessorsTest $.messageStruct }} {{ end }} -{{- if not .isCommon }} func generateTest{{ .structName }}() {{ .structName }} { + {{- if .isCommon }} + return {{ .structName }}(internal.GenerateTest{{ .structName }}()) + {{- else }} tv := New{{ .structName }}() fillTest{{ .structName }}(tv) return tv + {{- end }} } +{{ if not .isCommon -}} func fillTest{{ .structName }}(tv {{ .structName }}) { {{- range .fields }} {{ .GenerateSetWithTestValue $.messageStruct }} diff --git a/pdata/internal/cmd/pdatagen/internal/templates/slice.go.tmpl b/pdata/internal/cmd/pdatagen/internal/templates/slice.go.tmpl index 082c6c18cce..3e31640e4ed 100644 --- a/pdata/internal/cmd/pdatagen/internal/templates/slice.go.tmpl +++ b/pdata/internal/cmd/pdatagen/internal/templates/slice.go.tmpl @@ -19,13 +19,21 @@ import ( // // Must use New{{ .structName }} function to create new instances. // Important: zero-initialized instance is not valid for use. +{{- if .isCommon }} +type {{ .structName }} internal.{{ .structName }} +{{- else }} type {{ .structName }} struct { orig *[]{{ .originElementType }} state *internal.State } +{{- end }} func new{{ .structName }}(orig *[]{{ .originElementType }}, state *internal.State) {{ .structName }} { + {{- if .isCommon }} + return {{ .structName }}(internal.New{{ .structName }}(orig, state)) + {{- else }} return {{ .structName }}{orig: orig, state: state} + {{- end }} } // New{{ .structName }} creates a {{ .structName }} with 0 elements. @@ -40,7 +48,7 @@ func New{{ .structName }}() {{ .structName }} { // // Returns "0" for a newly instance created with "New{{ .structName }}()". func (es {{ .structName }}) Len() int { - return len(*es.orig) + return len(*es.{{ .origAccessor }}) } // At returns the element at the given index. @@ -66,45 +74,45 @@ func (es {{ .structName }}) At(i int) {{ .elementName }} { // // Here should set all the values for e. // } func (es {{ .structName }}) EnsureCapacity(newCap int) { - es.state.AssertMutable() - oldCap := cap(*es.orig) + es.{{ .stateAccessor }}.AssertMutable() + oldCap := cap(*es.{{ .origAccessor }}) if newCap <= oldCap { return } - newOrig := make([]{{ .originElementType }}, len(*es.orig), newCap) - copy(newOrig, *es.orig) - *es.orig = newOrig + newOrig := make([]{{ .originElementType }}, len(*es.{{ .origAccessor }}), newCap) + copy(newOrig, *es.{{ .origAccessor }}) + *es.{{ .origAccessor }} = newOrig } // AppendEmpty will append to the end of the slice an empty {{ .elementName }}. // It returns the newly added {{ .elementName }}. func (es {{ .structName }}) AppendEmpty() {{ .elementName }} { - es.state.AssertMutable() - *es.orig = append(*es.orig, {{ .emptyOriginElement }}) + es.{{ .stateAccessor }}.AssertMutable() + *es.{{ .origAccessor }} = append(*es.{{ .origAccessor }}, {{ .emptyOriginElement }}) return es.At(es.Len() - 1) } // MoveAndAppendTo moves all elements from the current slice and appends them to the dest. // The current slice will be cleared. func (es {{ .structName }}) MoveAndAppendTo(dest {{ .structName }}) { - es.state.AssertMutable() - dest.state.AssertMutable() - if *dest.orig == nil { + es.{{ .stateAccessor }}.AssertMutable() + dest.{{ .stateAccessor }}.AssertMutable() + if *dest.{{ .origAccessor }} == nil { // We can simply move the entire vector and avoid any allocations. - *dest.orig = *es.orig + *dest.{{ .origAccessor }} = *es.{{ .origAccessor }} } else { - *dest.orig = append(*dest.orig, *es.orig...) + *dest.{{ .origAccessor }} = append(*dest.{{ .origAccessor }}, *es.{{ .origAccessor }}...) } - *es.orig = nil + *es.{{ .origAccessor }} = nil } // RemoveIf calls f sequentially for each element present in the slice. // If f returns true, the element is removed from the slice. func (es {{ .structName }}) RemoveIf(f func({{ .elementName }}) bool) { - es.state.AssertMutable() + es.{{ .stateAccessor }}.AssertMutable() newLen := 0 - for i := 0; i < len(*es.orig); i++ { + for i := 0; i < len(*es.{{ .origAccessor }}); i++ { if f(es.At(i)) { continue } @@ -113,41 +121,41 @@ func (es {{ .structName }}) RemoveIf(f func({{ .elementName }}) bool) { newLen++ continue } - (*es.orig)[newLen] = (*es.orig)[i] + (*es.{{ .origAccessor }})[newLen] = (*es.{{ .origAccessor }})[i] newLen++ } - *es.orig = (*es.orig)[:newLen] + *es.{{ .origAccessor }} = (*es.{{ .origAccessor }})[:newLen] } // CopyTo copies all elements from the current slice overriding the destination. func (es {{ .structName }}) CopyTo(dest {{ .structName }}) { - dest.state.AssertMutable() + dest.{{ .stateAccessor }}.AssertMutable() srcLen := es.Len() - destCap := cap(*dest.orig) + destCap := cap(*dest.{{ .origAccessor }}) if srcLen <= destCap { - (*dest.orig) = (*dest.orig)[:srcLen:destCap] + (*dest.{{ .origAccessor }}) = (*dest.{{ .origAccessor }})[:srcLen:destCap] {{- if eq .type "sliceOfPtrs" }} - for i := range *es.orig { - new{{ .elementName }}((*es.orig)[i], es.state).CopyTo(new{{ .elementName }}((*dest.orig)[i], dest.state)) + for i := range *es.{{ .origAccessor }} { + new{{ .elementName }}((*es.{{ .origAccessor }})[i], es.{{ .stateAccessor }}).CopyTo(new{{ .elementName }}((*dest.{{ .origAccessor }})[i], dest.{{ .stateAccessor }})) } return } origs := make([]{{ .originName }}, srcLen) wrappers := make([]*{{ .originName }}, srcLen) - for i := range *es.orig { + for i := range *es.{{ .origAccessor }} { wrappers[i] = &origs[i] - new{{ .elementName }}((*es.orig)[i], es.state).CopyTo(new{{ .elementName }}(wrappers[i], dest.state)) + new{{ .elementName }}((*es.{{ .origAccessor }})[i], es.{{ .stateAccessor }}).CopyTo(new{{ .elementName }}(wrappers[i], dest.{{ .stateAccessor }})) } - *dest.orig = wrappers + *dest.{{ .origAccessor }} = wrappers {{- else }} } else { - (*dest.orig) = make([]{{ .originElementType }}, srcLen) + (*dest.{{ .origAccessor }}) = make([]{{ .originElementType }}, srcLen) } - for i := range *es.orig { - {{ .newElement }}.CopyTo(new{{ .elementName }}(&(*dest.orig)[i], dest.state)) + for i := range *es.{{ .origAccessor }} { + {{ .newElement }}.CopyTo(new{{ .elementName }}(&(*dest.{{ .origAccessor }})[i], dest.{{ .stateAccessor }})) } {{- end }} } @@ -157,7 +165,17 @@ func (es {{ .structName }}) CopyTo(dest {{ .structName }}) { // provided less function so that two instances of {{ .structName }} // can be compared. func (es {{ .structName }}) Sort(less func(a, b {{ .elementName }}) bool) { - es.state.AssertMutable() - sort.SliceStable(*es.orig, func(i, j int) bool { return less(es.At(i), es.At(j)) }) + es.{{ .stateAccessor }}.AssertMutable() + sort.SliceStable(*es.{{ .origAccessor }}, func(i, j int) bool { return less(es.At(i), es.At(j)) }) } -{{ end }} +{{- end }} + +{{ if .isCommon -}} +func (ms {{ .structName }}) getOrig() *[]{{ .originElementType }} { + return internal.GetOrig{{ .structName }}(internal.{{ .structName }}(ms)) +} + +func (ms {{ .structName }}) getState() *internal.State { + return internal.Get{{ .structName }}State(internal.{{ .structName }}(ms)) +} +{{- end }} diff --git a/pdata/internal/cmd/pdatagen/internal/templates/slice_internal.go.tmpl b/pdata/internal/cmd/pdatagen/internal/templates/slice_internal.go.tmpl new file mode 100644 index 00000000000..649c49ef14e --- /dev/null +++ b/pdata/internal/cmd/pdatagen/internal/templates/slice_internal.go.tmpl @@ -0,0 +1,49 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by "pdata/internal/cmd/pdatagen/main.go". DO NOT EDIT. +// To regenerate this file run "make genpdata". + +package internal + +import ( + {{ range $index, $element := .imports -}} + {{ if ne $element `"go.opentelemetry.io/collector/pdata/internal"` }} + {{ $element }} + {{ end }} + {{ end }} +) + + +type {{ .structName }} struct { + orig *[]{{ .originElementType }} + state *State +} + +func GetOrig{{ .structName }}(ms {{ .structName }}) *[]{{ .originElementType }} { + return ms.orig +} + +func Get{{ .structName }}State(ms {{ .structName }}) *State { + return ms.state +} + +func New{{ .structName }}(orig *[]{{ .originElementType }}, state *State) {{ .structName }} { + return {{ .structName }}{orig: orig, state: state} +} + +func GenerateTest{{ .structName }}() {{ .structName }} { + orig := []{{ .originElementType }}(nil) + state := StateMutable + es := New{{ .structName }}(&orig, &state) + FillTest{{ .structName }}(es) + return es +} + +func FillTest{{ .structName }}(es {{ .structName }}) { + *es.orig = make([]{{ .originElementType }}, 7) + for i := 0; i < 7; i++ { + (*es.orig)[i] = {{ .emptyOriginElement }} + FillTest{{ .elementName }}(New{{ .elementName }}((*es.orig)[i], es.state)) + } +} diff --git a/pdata/internal/cmd/pdatagen/internal/templates/slice_test.go.tmpl b/pdata/internal/cmd/pdatagen/internal/templates/slice_test.go.tmpl index 8b947a5ac8b..fc96a9c62f7 100644 --- a/pdata/internal/cmd/pdatagen/internal/templates/slice_test.go.tmpl +++ b/pdata/internal/cmd/pdatagen/internal/templates/slice_test.go.tmpl @@ -20,11 +20,19 @@ func Test{{ .structName }}(t *testing.T) { assert.Equal(t, 0, es.Len()) emptyVal := New{{ .elementName }}() + {{- if .isCommon }} + testVal := {{ .elementName }}(internal.GenerateTest{{ .elementName }}()) + {{- else }} testVal := generateTest{{ .elementName }}() + {{- end }} for i := 0; i < 7; i++ { el := es.AppendEmpty() assert.Equal(t, emptyVal, es.At(i)) + {{- if .isCommon }} + internal.FillTest{{ .elementName }}(internal.{{ .elementName }}(el)) + {{- else }} fillTest{{ .elementName }}(el) + {{- end }} assert.Equal(t, testVal, es.At(i)) } assert.Equal(t, 7, es.Len()) @@ -65,14 +73,14 @@ func Test{{ .structName }}_EnsureCapacity(t *testing.T) { const ensureSmallLen = 4 es.EnsureCapacity(ensureSmallLen) assert.Less(t, ensureSmallLen, es.Len()) - assert.Equal(t, es.Len(), cap(*es.orig)) + assert.Equal(t, es.Len(), cap(*es.{{ .origAccessor }})) assert.Equal(t, generateTest{{ .structName }}(), es) // Test ensure larger capacity const ensureLargeLen = 9 es.EnsureCapacity(ensureLargeLen) assert.Less(t, generateTest{{ .structName }}().Len(), ensureLargeLen) - assert.Equal(t, ensureLargeLen, cap(*es.orig)) + assert.Equal(t, ensureLargeLen, cap(*es.{{ .origAccessor }})) assert.Equal(t, generateTest{{ .structName }}(), es) } @@ -123,26 +131,31 @@ func Test{{ .structName }}_RemoveIf(t *testing.T) { func Test{{ .structName }}_Sort(t *testing.T) { es := generateTest{{ .structName }}() es.Sort(func(a, b {{ .elementName }}) bool { - return uintptr(unsafe.Pointer(a.orig)) < uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.{{ .origAccessor }})) < uintptr(unsafe.Pointer(b.{{ .origAccessor }})) }) for i := 1; i < es.Len(); i++ { - assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Less(t, uintptr(unsafe.Pointer(es.At(i-1).{{ .origAccessor }})), uintptr(unsafe.Pointer(es.At(i).{{ .origAccessor }}))) } es.Sort(func(a, b {{ .elementName }}) bool { - return uintptr(unsafe.Pointer(a.orig)) > uintptr(unsafe.Pointer(b.orig)) + return uintptr(unsafe.Pointer(a.{{ .origAccessor }})) > uintptr(unsafe.Pointer(b.{{ .origAccessor }})) }) for i := 1; i < es.Len(); i++ { - assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).orig)), uintptr(unsafe.Pointer(es.At(i).orig))) + assert.Greater(t, uintptr(unsafe.Pointer(es.At(i-1).{{ .origAccessor }})), uintptr(unsafe.Pointer(es.At(i).{{ .origAccessor }}))) } } {{- end }} func generateTest{{ .structName }}() {{ .structName }} { + {{- if .isCommon }} + return {{ .structName }}(internal.GenerateTest{{ .structName }}()) + {{- else }} es := New{{ .structName }}() fillTest{{ .structName }}(es) return es + {{- end }} } +{{ if not .isCommon -}} func fillTest{{ .structName }}(es {{ .structName }}) { *es.orig = make([]{{ .originElementType }}, 7) for i := 0; i < 7; i++ { @@ -150,3 +163,4 @@ func fillTest{{ .structName }}(es {{ .structName }}) { fillTest{{ .elementName }}({{ .newElement }}) } } +{{- end }} diff --git a/pdata/pcommon/generated_instrumentationscope_test.go b/pdata/pcommon/generated_instrumentationscope_test.go index 8dc46fe69c4..23fb4cbb080 100644 --- a/pdata/pcommon/generated_instrumentationscope_test.go +++ b/pdata/pcommon/generated_instrumentationscope_test.go @@ -16,11 +16,11 @@ import ( ) func TestInstrumentationScope_MoveTo(t *testing.T) { - ms := InstrumentationScope(internal.GenerateTestInstrumentationScope()) + ms := generateTestInstrumentationScope() dest := NewInstrumentationScope() ms.MoveTo(dest) assert.Equal(t, NewInstrumentationScope(), ms) - assert.Equal(t, InstrumentationScope(internal.GenerateTestInstrumentationScope()), dest) + assert.Equal(t, generateTestInstrumentationScope(), dest) sharedState := internal.StateReadOnly assert.Panics(t, func() { ms.MoveTo(newInstrumentationScope(&otlpcommon.InstrumentationScope{}, &sharedState)) }) assert.Panics(t, func() { newInstrumentationScope(&otlpcommon.InstrumentationScope{}, &sharedState).MoveTo(dest) }) @@ -31,7 +31,7 @@ func TestInstrumentationScope_CopyTo(t *testing.T) { orig := NewInstrumentationScope() orig.CopyTo(ms) assert.Equal(t, orig, ms) - orig = InstrumentationScope(internal.GenerateTestInstrumentationScope()) + orig = generateTestInstrumentationScope() orig.CopyTo(ms) assert.Equal(t, orig, ms) sharedState := internal.StateReadOnly @@ -75,3 +75,7 @@ func TestInstrumentationScope_DroppedAttributesCount(t *testing.T) { newInstrumentationScope(&otlpcommon.InstrumentationScope{}, &sharedState).SetDroppedAttributesCount(uint32(17)) }) } + +func generateTestInstrumentationScope() InstrumentationScope { + return InstrumentationScope(internal.GenerateTestInstrumentationScope()) +} diff --git a/pdata/pcommon/generated_resource_test.go b/pdata/pcommon/generated_resource_test.go index a7af5300fe8..0397781aead 100644 --- a/pdata/pcommon/generated_resource_test.go +++ b/pdata/pcommon/generated_resource_test.go @@ -16,11 +16,11 @@ import ( ) func TestResource_MoveTo(t *testing.T) { - ms := Resource(internal.GenerateTestResource()) + ms := generateTestResource() dest := NewResource() ms.MoveTo(dest) assert.Equal(t, NewResource(), ms) - assert.Equal(t, Resource(internal.GenerateTestResource()), dest) + assert.Equal(t, generateTestResource(), dest) sharedState := internal.StateReadOnly assert.Panics(t, func() { ms.MoveTo(newResource(&otlpresource.Resource{}, &sharedState)) }) assert.Panics(t, func() { newResource(&otlpresource.Resource{}, &sharedState).MoveTo(dest) }) @@ -31,7 +31,7 @@ func TestResource_CopyTo(t *testing.T) { orig := NewResource() orig.CopyTo(ms) assert.Equal(t, orig, ms) - orig = Resource(internal.GenerateTestResource()) + orig = generateTestResource() orig.CopyTo(ms) assert.Equal(t, orig, ms) sharedState := internal.StateReadOnly @@ -53,3 +53,7 @@ func TestResource_DroppedAttributesCount(t *testing.T) { sharedState := internal.StateReadOnly assert.Panics(t, func() { newResource(&otlpresource.Resource{}, &sharedState).SetDroppedAttributesCount(uint32(17)) }) } + +func generateTestResource() Resource { + return Resource(internal.GenerateTestResource()) +}