Refactor exponential histogram tests to use existing fixtures (#4747)

* Refactor expo hist test to use existing fixtures

The tests for the exponential histogram create their own testing
fixtures. There is nothing these new fixtures do that cannot already be
done with the existing testing fixtures used by all the other aggregate
functions. Unify the exponential histogram testing to use the existing
fixtures.

* Add alt input for cumulative test

sdk/metric/internal/aggregate/exponential_histogram_test.go

@@ -23,10 +23,8 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/internal/global"
 	"go.opentelemetry.io/otel/sdk/metric/metricdata"
-	"go.opentelemetry.io/otel/sdk/metric/metricdata/metricdatatest"
 )
 
 type noErrorHandler struct{ t *testing.T }
@@ -739,39 +737,112 @@ func TestSubNormal(t *testing.T) {
 }
 
 func TestExponentialHistogramAggregation(t *testing.T) {
-	t.Run("Int64", testExponentialHistogramAggregation[int64])
+	t.Cleanup(mockTime(now))
-	t.Run("Float64", testExponentialHistogramAggregation[float64])
+
+	t.Run("Int64/Delta", testDeltaExpoHist[int64]())
+	t.Run("Float64/Delta", testDeltaExpoHist[float64]())
+	t.Run("Int64/Cumulative", testCumulativeExpoHist[int64]())
+	t.Run("Float64/Cumulative", testCumulativeExpoHist[float64]())
 }
 
-func testExponentialHistogramAggregation[N int64 | float64](t *testing.T) {
+func testDeltaExpoHist[N int64 | float64]() func(t *testing.T) {
-	const (
+	in, out := Builder[N]{
-		maxSize  = 4
+		Temporality: metricdata.DeltaTemporality,
-		maxScale = 20
+		Filter:      attrFltr,
-		noMinMax = false
+	}.ExponentialBucketHistogram(4, 20, false, false)
-		noSum    = false
+	ctx := context.Background()
-	)
+	return test[N](in, out, []teststep[N]{
+		{
+			input: []arg[N]{},
+			expect: output{
+				n: 0,
+				agg: metricdata.ExponentialHistogram[N]{
+					Temporality: metricdata.DeltaTemporality,
+					DataPoints:  []metricdata.ExponentialHistogramDataPoint[N]{},
+				},
+			},
+		},
+		{
+			input: []arg[N]{
+				{ctx, 4, alice},
+				{ctx, 4, alice},
+				{ctx, 4, alice},
+				{ctx, 2, alice},
+				{ctx, 16, alice},
+				{ctx, 1, alice},
+			},
+			expect: output{
+				n: 1,
+				agg: metricdata.ExponentialHistogram[N]{
+					Temporality: metricdata.DeltaTemporality,
+					DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
+						{
+							Attributes: fltrAlice,
+							StartTime:  staticTime,
+							Time:       staticTime,
+							Count:      6,
+							Min:        metricdata.NewExtrema[N](1),
+							Max:        metricdata.NewExtrema[N](16),
+							Sum:        31,
+							Scale:      -1,
+							PositiveBucket: metricdata.ExponentialBucket{
+								Offset: -1,
+								Counts: []uint64{1, 4, 1},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			// Delta sums are expected to reset.
+			input: []arg[N]{},
+			expect: output{
+				n: 0,
+				agg: metricdata.ExponentialHistogram[N]{
+					Temporality: metricdata.DeltaTemporality,
+					DataPoints:  []metricdata.ExponentialHistogramDataPoint[N]{},
+				},
+			},
+		},
+	})
+}
 
-	tests := []struct {
+func testCumulativeExpoHist[N int64 | float64]() func(t *testing.T) {
-		name      string
+	in, out := Builder[N]{
-		build     func() (Measure[N], ComputeAggregation)
+		Temporality: metricdata.CumulativeTemporality,
-		input     [][]N
+		Filter:      attrFltr,
-		want      metricdata.ExponentialHistogram[N]
+	}.ExponentialBucketHistogram(4, 20, false, false)
-		wantCount int
+	ctx := context.Background()
-	}{
+	return test[N](in, out, []teststep[N]{
 		{
-			name: "Delta Single",
+			input: []arg[N]{},
-			build: func() (Measure[N], ComputeAggregation) {
+			expect: output{
-				return Builder[N]{
+				n: 0,
-					Temporality: metricdata.DeltaTemporality,
+				agg: metricdata.ExponentialHistogram[N]{
-				}.ExponentialBucketHistogram(maxSize, maxScale, noMinMax, noSum)
+					Temporality: metricdata.CumulativeTemporality,
+					DataPoints:  []metricdata.ExponentialHistogramDataPoint[N]{},
 				},
-			input: [][]N{
-				{4, 4, 4, 2, 16, 1},
 			},
-			want: metricdata.ExponentialHistogram[N]{
+		},
-				Temporality: metricdata.DeltaTemporality,
+		{
+			input: []arg[N]{
+				{ctx, 4, alice},
+				{ctx, 4, alice},
+				{ctx, 4, alice},
+				{ctx, 2, alice},
+				{ctx, 16, alice},
+				{ctx, 1, alice},
+			},
+			expect: output{
+				n: 1,
+				agg: metricdata.ExponentialHistogram[N]{
+					Temporality: metricdata.CumulativeTemporality,
 					DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
 						{
+							Attributes: fltrAlice,
+							StartTime:  staticTime,
+							Time:       staticTime,
 							Count:      6,
 							Min:        metricdata.NewExtrema[N](1),
 							Max:        metricdata.NewExtrema[N](16),
@@ -784,80 +855,23 @@ func testExponentialHistogramAggregation[N int64 | float64](t *testing.T) {
 						},
 					},
 				},
-			wantCount: 1,
+			},
 		},
 		{
-			name: "Cumulative Single",
+			input: []arg[N]{
-			build: func() (Measure[N], ComputeAggregation) {
+				{ctx, 2, alice},
-				return Builder[N]{
+				{ctx, 3, alice},
-					Temporality: metricdata.CumulativeTemporality,
+				{ctx, 8, alice},
-				}.ExponentialBucketHistogram(maxSize, maxScale, noMinMax, noSum)
 			},
-			input: [][]N{
+			expect: output{
-				{4, 4, 4, 2, 16, 1},
+				n: 1,
-			},
+				agg: metricdata.ExponentialHistogram[N]{
-			want: metricdata.ExponentialHistogram[N]{
-				Temporality: metricdata.CumulativeTemporality,
-				DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
-					{
-						Count: 6,
-						Min:   metricdata.NewExtrema[N](1),
-						Max:   metricdata.NewExtrema[N](16),
-						Sum:   31,
-						Scale: -1,
-						PositiveBucket: metricdata.ExponentialBucket{
-							Offset: -1,
-							Counts: []uint64{1, 4, 1},
-						},
-					},
-				},
-			},
-			wantCount: 1,
-		},
-		{
-			name: "Delta Multiple",
-			build: func() (Measure[N], ComputeAggregation) {
-				return Builder[N]{
-					Temporality: metricdata.DeltaTemporality,
-				}.ExponentialBucketHistogram(maxSize, maxScale, noMinMax, noSum)
-			},
-			input: [][]N{
-				{2, 3, 8},
-				{4, 4, 4, 2, 16, 1},
-			},
-			want: metricdata.ExponentialHistogram[N]{
-				Temporality: metricdata.DeltaTemporality,
-				DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
-					{
-						Count: 6,
-						Min:   metricdata.NewExtrema[N](1),
-						Max:   metricdata.NewExtrema[N](16),
-						Sum:   31,
-						Scale: -1,
-						PositiveBucket: metricdata.ExponentialBucket{
-							Offset: -1,
-							Counts: []uint64{1, 4, 1},
-						},
-					},
-				},
-			},
-			wantCount: 1,
-		},
-		{
-			name: "Cumulative Multiple ",
-			build: func() (Measure[N], ComputeAggregation) {
-				return Builder[N]{
-					Temporality: metricdata.CumulativeTemporality,
-				}.ExponentialBucketHistogram(maxSize, maxScale, noMinMax, noSum)
-			},
-			input: [][]N{
-				{2, 3, 8},
-				{4, 4, 4, 2, 16, 1},
-			},
-			want: metricdata.ExponentialHistogram[N]{
 					Temporality: metricdata.CumulativeTemporality,
 					DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
 						{
+							Attributes: fltrAlice,
+							StartTime:  staticTime,
+							Time:       staticTime,
 							Count:      9,
 							Min:        metricdata.NewExtrema[N](1),
 							Max:        metricdata.NewExtrema[N](16),
@@ -870,31 +884,35 @@ func testExponentialHistogramAggregation[N int64 | float64](t *testing.T) {
 						},
 					},
 				},
-			wantCount: 1,
 			},
-	}
+		},
-
+		{
-	for _, tt := range tests {
+			input: []arg[N]{},
-		t.Run(tt.name, func(t *testing.T) {
+			expect: output{
-			restore := withHandler(t)
+				n: 1,
-			defer restore()
+				agg: metricdata.ExponentialHistogram[N]{
-			in, out := tt.build()
+					Temporality: metricdata.CumulativeTemporality,
-			ctx := context.Background()
+					DataPoints: []metricdata.ExponentialHistogramDataPoint[N]{
-
+						{
-			var got metricdata.Aggregation
+							Attributes: fltrAlice,
-			var count int
+							StartTime:  staticTime,
-			for _, n := range tt.input {
+							Time:       staticTime,
-				for _, v := range n {
+							Count:      9,
-					in(ctx, v, *attribute.EmptySet())
+							Min:        metricdata.NewExtrema[N](1),
-				}
+							Max:        metricdata.NewExtrema[N](16),
-				count = out(&got)
+							Sum:        44,
-			}
+							Scale:      -1,
-
+							PositiveBucket: metricdata.ExponentialBucket{
-			metricdatatest.AssertAggregationsEqual(t, tt.want, got, metricdatatest.IgnoreTimestamp())
+								Offset: -1,
-			assert.Equal(t, tt.wantCount, count)
+								Counts: []uint64{1, 6, 2},
+							},
+						},
+					},
+				},
+			},
+		},
 	})
 }
-}
 
 func FuzzGetBin(f *testing.F) {
 	values := []float64{