[chore] [pdata] Fix the generated tests for slices (#7112)

The loop was never executed before

pdata/internal/cmd/pdatagen/internal/base_slices.go

@@ -200,16 +200,15 @@ const slicePtrTestTemplate = `func Test${structName}(t *testing.T) {
 	es = new${structName}(&[]*${originName}{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := new${elementName}(&${originName}{})
+	emptyVal := New${elementName}()
 	testVal := generateTest${elementName}()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTest${elementName}(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func Test${structName}_CopyTo(t *testing.T) {
@@ -351,16 +350,15 @@ const sliceValueTestTemplate = `func Test${structName}(t *testing.T) {
 	es = new${structName}(&[]${originName}{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := new${elementName}(&${originName}{})
+	emptyVal := New${elementName}()
 	testVal := generateTest${elementName}()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTest${elementName}(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func Test${structName}_CopyTo(t *testing.T) {

pdata/plog/generated_logrecordslice_test.go

@@ -31,16 +31,15 @@ func TestLogRecordSlice(t *testing.T) {
 	es = newLogRecordSlice(&[]*otlplogs.LogRecord{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newLogRecord(&otlplogs.LogRecord{})
+	emptyVal := NewLogRecord()
 	testVal := generateTestLogRecord()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestLogRecord(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestLogRecordSlice_CopyTo(t *testing.T) {

pdata/plog/generated_resourcelogsslice_test.go

@@ -31,16 +31,15 @@ func TestResourceLogsSlice(t *testing.T) {
 	es = newResourceLogsSlice(&[]*otlplogs.ResourceLogs{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newResourceLogs(&otlplogs.ResourceLogs{})
+	emptyVal := NewResourceLogs()
 	testVal := generateTestResourceLogs()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestResourceLogs(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestResourceLogsSlice_CopyTo(t *testing.T) {

pdata/plog/generated_scopelogsslice_test.go

@@ -31,16 +31,15 @@ func TestScopeLogsSlice(t *testing.T) {
 	es = newScopeLogsSlice(&[]*otlplogs.ScopeLogs{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newScopeLogs(&otlplogs.ScopeLogs{})
+	emptyVal := NewScopeLogs()
 	testVal := generateTestScopeLogs()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestScopeLogs(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestScopeLogsSlice_CopyTo(t *testing.T) {

pdata/pmetric/generated_exemplarslice_test.go

@@ -31,16 +31,15 @@ func TestExemplarSlice(t *testing.T) {
 	es = newExemplarSlice(&[]otlpmetrics.Exemplar{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newExemplar(&otlpmetrics.Exemplar{})
+	emptyVal := NewExemplar()
 	testVal := generateTestExemplar()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestExemplar(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestExemplarSlice_CopyTo(t *testing.T) {

pdata/pmetric/generated_exponentialhistogramdatapointslice_test.go

@@ -31,16 +31,15 @@ func TestExponentialHistogramDataPointSlice(t *testing.T) {
 	es = newExponentialHistogramDataPointSlice(&[]*otlpmetrics.ExponentialHistogramDataPoint{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newExponentialHistogramDataPoint(&otlpmetrics.ExponentialHistogramDataPoint{})
+	emptyVal := NewExponentialHistogramDataPoint()
 	testVal := generateTestExponentialHistogramDataPoint()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestExponentialHistogramDataPoint(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestExponentialHistogramDataPointSlice_CopyTo(t *testing.T) {

pdata/pmetric/generated_histogramdatapointslice_test.go

@@ -31,16 +31,15 @@ func TestHistogramDataPointSlice(t *testing.T) {
 	es = newHistogramDataPointSlice(&[]*otlpmetrics.HistogramDataPoint{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newHistogramDataPoint(&otlpmetrics.HistogramDataPoint{})
+	emptyVal := NewHistogramDataPoint()
 	testVal := generateTestHistogramDataPoint()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestHistogramDataPoint(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestHistogramDataPointSlice_CopyTo(t *testing.T) {

pdata/pmetric/generated_metricslice_test.go

@@ -31,16 +31,15 @@ func TestMetricSlice(t *testing.T) {
 	es = newMetricSlice(&[]*otlpmetrics.Metric{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newMetric(&otlpmetrics.Metric{})
+	emptyVal := NewMetric()
 	testVal := generateTestMetric()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestMetric(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestMetricSlice_CopyTo(t *testing.T) {

pdata/pmetric/generated_numberdatapointslice_test.go

@@ -31,16 +31,15 @@ func TestNumberDataPointSlice(t *testing.T) {
 	es = newNumberDataPointSlice(&[]*otlpmetrics.NumberDataPoint{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newNumberDataPoint(&otlpmetrics.NumberDataPoint{})
+	emptyVal := NewNumberDataPoint()
 	testVal := generateTestNumberDataPoint()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestNumberDataPoint(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestNumberDataPointSlice_CopyTo(t *testing.T) {

pdata/pmetric/generated_resourcemetricsslice_test.go

@@ -31,16 +31,15 @@ func TestResourceMetricsSlice(t *testing.T) {
 	es = newResourceMetricsSlice(&[]*otlpmetrics.ResourceMetrics{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newResourceMetrics(&otlpmetrics.ResourceMetrics{})
+	emptyVal := NewResourceMetrics()
 	testVal := generateTestResourceMetrics()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestResourceMetrics(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestResourceMetricsSlice_CopyTo(t *testing.T) {

pdata/pmetric/generated_scopemetricsslice_test.go

@@ -31,16 +31,15 @@ func TestScopeMetricsSlice(t *testing.T) {
 	es = newScopeMetricsSlice(&[]*otlpmetrics.ScopeMetrics{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newScopeMetrics(&otlpmetrics.ScopeMetrics{})
+	emptyVal := NewScopeMetrics()
 	testVal := generateTestScopeMetrics()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestScopeMetrics(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestScopeMetricsSlice_CopyTo(t *testing.T) {

pdata/pmetric/generated_summarydatapointslice_test.go

@@ -31,16 +31,15 @@ func TestSummaryDataPointSlice(t *testing.T) {
 	es = newSummaryDataPointSlice(&[]*otlpmetrics.SummaryDataPoint{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newSummaryDataPoint(&otlpmetrics.SummaryDataPoint{})
+	emptyVal := NewSummaryDataPoint()
 	testVal := generateTestSummaryDataPoint()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestSummaryDataPoint(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestSummaryDataPointSlice_CopyTo(t *testing.T) {

pdata/pmetric/generated_summarydatapointvalueatquantileslice_test.go

@@ -31,16 +31,15 @@ func TestSummaryDataPointValueAtQuantileSlice(t *testing.T) {
 	es = newSummaryDataPointValueAtQuantileSlice(&[]*otlpmetrics.SummaryDataPoint_ValueAtQuantile{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newSummaryDataPointValueAtQuantile(&otlpmetrics.SummaryDataPoint_ValueAtQuantile{})
+	emptyVal := NewSummaryDataPointValueAtQuantile()
 	testVal := generateTestSummaryDataPointValueAtQuantile()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestSummaryDataPointValueAtQuantile(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestSummaryDataPointValueAtQuantileSlice_CopyTo(t *testing.T) {

pdata/ptrace/generated_resourcespansslice_test.go

@@ -31,16 +31,15 @@ func TestResourceSpansSlice(t *testing.T) {
 	es = newResourceSpansSlice(&[]*otlptrace.ResourceSpans{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newResourceSpans(&otlptrace.ResourceSpans{})
+	emptyVal := NewResourceSpans()
 	testVal := generateTestResourceSpans()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestResourceSpans(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestResourceSpansSlice_CopyTo(t *testing.T) {

pdata/ptrace/generated_scopespansslice_test.go

@@ -31,16 +31,15 @@ func TestScopeSpansSlice(t *testing.T) {
 	es = newScopeSpansSlice(&[]*otlptrace.ScopeSpans{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newScopeSpans(&otlptrace.ScopeSpans{})
+	emptyVal := NewScopeSpans()
 	testVal := generateTestScopeSpans()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestScopeSpans(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestScopeSpansSlice_CopyTo(t *testing.T) {

pdata/ptrace/generated_spaneventslice_test.go

@@ -31,16 +31,15 @@ func TestSpanEventSlice(t *testing.T) {
 	es = newSpanEventSlice(&[]*otlptrace.Span_Event{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newSpanEvent(&otlptrace.Span_Event{})
+	emptyVal := NewSpanEvent()
 	testVal := generateTestSpanEvent()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestSpanEvent(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestSpanEventSlice_CopyTo(t *testing.T) {

pdata/ptrace/generated_spanlinkslice_test.go

@@ -31,16 +31,15 @@ func TestSpanLinkSlice(t *testing.T) {
 	es = newSpanLinkSlice(&[]*otlptrace.Span_Link{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newSpanLink(&otlptrace.Span_Link{})
+	emptyVal := NewSpanLink()
 	testVal := generateTestSpanLink()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestSpanLink(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestSpanLinkSlice_CopyTo(t *testing.T) {

pdata/ptrace/generated_spanslice_test.go

@@ -31,16 +31,15 @@ func TestSpanSlice(t *testing.T) {
 	es = newSpanSlice(&[]*otlptrace.Span{})
 	assert.Equal(t, 0, es.Len())
 
-	es.EnsureCapacity(7)
-	emptyVal := newSpan(&otlptrace.Span{})
+	emptyVal := NewSpan()
 	testVal := generateTestSpan()
-	assert.Equal(t, 7, cap(*es.orig))
-	for i := 0; i < es.Len(); i++ {
+	for i := 0; i < 7; i++ {
 		el := es.AppendEmpty()
-		assert.Equal(t, emptyVal, el)
+		assert.Equal(t, emptyVal, es.At(i))
 		fillTestSpan(el)
-		assert.Equal(t, testVal, el)
+		assert.Equal(t, testVal, es.At(i))
 	}
+	assert.Equal(t, 7, es.Len())
 }
 
 func TestSpanSlice_CopyTo(t *testing.T) {