open-telemetry
/
opentelemetry-collector
mirror of https://github.com/open-telemetry/opentelemetry-collector.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

The loop was never executed before
This commit is contained in:
Dmitrii Anoshin 2023-02-03 11:02:13 -08:00 committed by GitHub
parent 93bc33891b
commit a8cfb51cec
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 95 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
pdata/internal/cmd/pdatagen/internal/base_slices.go
View File

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

11
pdata/plog/generated_logrecordslice_test.go
View File

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

11
pdata/plog/generated_resourcelogsslice_test.go
View File

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

11
pdata/plog/generated_scopelogsslice_test.go
View File

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

11
pdata/pmetric/generated_exemplarslice_test.go
View File

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

11
pdata/pmetric/generated_exponentialhistogramdatapointslice_test.go
View File

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

11
pdata/pmetric/generated_histogramdatapointslice_test.go
View File

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

11
pdata/pmetric/generated_metricslice_test.go
View File

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

11
pdata/pmetric/generated_numberdatapointslice_test.go
View File

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

11
pdata/pmetric/generated_resourcemetricsslice_test.go
View File

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

11
pdata/pmetric/generated_scopemetricsslice_test.go
View File

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

11
pdata/pmetric/generated_summarydatapointslice_test.go
View File

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

11
pdata/pmetric/generated_summarydatapointvalueatquantileslice_test.go
View File

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

11
pdata/ptrace/generated_resourcespansslice_test.go
View File

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

11
pdata/ptrace/generated_scopespansslice_test.go
View File

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

11
pdata/ptrace/generated_spaneventslice_test.go
View File

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

11
pdata/ptrace/generated_spanlinkslice_test.go
View File

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

11
pdata/ptrace/generated_spanslice_test.go
View File

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