[chore]: enable float-compare rule from testifylint

Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>

.golangci.yml

@@ -134,7 +134,6 @@ linters-settings:
 
   testifylint:
     disable:
-      - float-compare
       - formatter
       - go-require
       - require-error

Makefile.Common

@@ -77,7 +77,7 @@ GOTESTSUM           := $(TOOLS_BIN_DIR)/gotestsum
 TESTIFYLINT         := $(TOOLS_BIN_DIR)/testifylint
 
 GOTESTSUM_OPT?= --rerun-fails=1
-TESTIFYLINT_OPT?= --enable-all --disable=float-compare,formatter,go-require,require-error,suite-subtest-run,useless-assert
+TESTIFYLINT_OPT?= --enable-all --disable=formatter,go-require,require-error,suite-subtest-run,useless-assert
 
 # BUILD_TYPE should be one of (dev, release).
 BUILD_TYPE?=release

connector/routingconnector/metrics_test.go

@@ -219,7 +219,7 @@ func TestMetricsAreCorrectlySplitPerResourceAttributeWithOTTL(t *testing.T) {
 		rmetric := defaultSink.AllMetrics()[0].ResourceMetrics().At(0)
 		attr, ok := rmetric.Resource().Attributes().Get("value")
 		assert.True(t, ok, "routing attribute must exist")
-		assert.Equal(t, attr.Double(), float64(-1.0))
+		assert.InDelta(t, attr.Double(), float64(-1.0), 0.01)
 	})
 
 	t.Run("metric matched by one expression, multiple pipelines", func(t *testing.T) {
@@ -386,7 +386,7 @@ func TestMetricsAreCorrectlyMatchOnceWithOTTL(t *testing.T) {
 		rmetric := defaultSink.AllMetrics()[0].ResourceMetrics().At(0)
 		attr, ok := rmetric.Resource().Attributes().Get("value")
 		assert.True(t, ok, "routing attribute must exist")
-		assert.Equal(t, attr.Double(), float64(-1.0))
+		assert.InDelta(t, attr.Double(), float64(-1.0), 0.01)
 	})
 
 	t.Run("metric matched by one expression, multiple pipelines", func(t *testing.T) {

exporter/alertmanagerexporter/alertmanager_exporter_test.go

@@ -143,7 +143,7 @@ func TestAlertManagerExporterEventNameAttributes(t *testing.T) {
 	assert.Equal(t, "unittest-baz", attr.AsString())
 	attr, b = got[0].spanEvent.Attributes().Get("attr3")
 	assert.True(t, b)
-	assert.Equal(t, 5.14, attr.Double())
+	assert.InDelta(t, 5.14, attr.Double(), 0.01)
 }
 
 func TestAlertManagerExporterSeverity(t *testing.T) {

exporter/awsemfexporter/datapoint_test.go

@@ -1473,22 +1473,22 @@ func TestGetDataPoints(t *testing.T) {
 				dp := convertedDPS.NumberDataPointSlice.At(0)
 				switch dp.ValueType() {
 				case pmetric.NumberDataPointValueTypeDouble:
-					assert.Equal(t, 0.1, dp.DoubleValue())
+					assert.InDelta(t, 0.1, dp.DoubleValue(), 0.01)
 				case pmetric.NumberDataPointValueTypeInt:
 					assert.Equal(t, int64(1), dp.IntValue())
 				}
 				assert.Equal(t, tc.expectedAttributes, dp.Attributes().AsRaw())
 			case histogramDataPointSlice:
 				assert.Equal(t, 1, convertedDPS.Len())
 				dp := convertedDPS.HistogramDataPointSlice.At(0)
-				assert.Equal(t, 35.0, dp.Sum())
+				assert.InDelta(t, 35.0, dp.Sum(), 0.01)
 				assert.Equal(t, uint64(18), dp.Count())
 				assert.Equal(t, []float64{0, 10}, dp.ExplicitBounds().AsRaw())
 				assert.Equal(t, tc.expectedAttributes, dp.Attributes().AsRaw())
 			case exponentialHistogramDataPointSlice:
 				assert.Equal(t, 1, convertedDPS.Len())
 				dp := convertedDPS.ExponentialHistogramDataPointSlice.At(0)
-				assert.Equal(t, float64(0), dp.Sum())
+				assert.InDelta(t, float64(0), dp.Sum(), 0.01)
 				assert.Equal(t, uint64(4), dp.Count())
 				assert.Equal(t, []uint64{1, 0, 1}, dp.Positive().BucketCounts().AsRaw())
 				assert.Equal(t, []uint64{1, 0, 1}, dp.Negative().BucketCounts().AsRaw())

exporter/datadogexporter/internal/metrics/series_deprecated_test.go

@@ -20,9 +20,9 @@ func TestNewZorkianMetric(t *testing.T) {
 
 	assert.Equal(t, "test.metric", *metric.Metric)
 	// Assert timestamp conversion from uint64 ns to float64 s
-	assert.Equal(t, 1.0, *metric.Points[0][0])
+	assert.InDelta(t, 1.0, *metric.Points[0][0], 0.01)
 	// Assert value
-	assert.Equal(t, 2.0, *metric.Points[0][1])
+	assert.InDelta(t, 2.0, *metric.Points[0][1], 0.01)
 	// Assert tags
 	assert.Equal(t, []string{"tag:value"}, metric.Tags)
 }
@@ -53,7 +53,7 @@ func TestDefaultZorkianMetrics(t *testing.T) {
 	// Assert metrics list length (should be 1)
 	assert.Len(t, ms, 1)
 	// Assert timestamp
-	assert.Equal(t, 2.0, *ms[0].Points[0][0])
+	assert.InDelta(t, 2.0, *ms[0].Points[0][0], 0.01)
 	// Assert value (should always be 1.0)
 	assert.Equal(t, 1.0, *ms[0].Points[0][1])
 	// Assert hostname tag is set

exporter/datadogexporter/internal/metrics/sketches/sketches_test.go

@@ -60,8 +60,8 @@ func check(t *testing.T, in SketchPoint, pb gogen.SketchPayload_Sketch_Dogsketch
 
 	// summary
 	require.Equal(t, b.Cnt, pb.Cnt)
-	require.Equal(t, b.Min, pb.Min)
-	require.Equal(t, b.Max, pb.Max)
+	require.InDelta(t, b.Min, pb.Min, 0.01)
+	require.InDelta(t, b.Max, pb.Max, 0.01)
 	require.Equal(t, b.Avg, pb.Avg)
 	require.Equal(t, b.Sum, pb.Sum)
 }

exporter/logzioexporter/exporter_test.go

@@ -295,11 +295,11 @@ func TestPushLogsData(tester *testing.T) {
 	assert.Equal(tester, testHost, jsonLog["host.name"])
 	assert.Equal(tester, testService, jsonLog["service.name"])
 	assert.Equal(tester, "server", jsonLog["app"])
-	assert.Equal(tester, 1.0, jsonLog["instance_num"])
+	assert.InDelta(tester, 1.0, jsonLog["instance_num"], 0.01)
 	assert.Equal(tester, "logScopeName", jsonLog["scopeName"])
 	assert.Equal(tester, "hello there", jsonLog["message"])
 	assert.Equal(tester, "bar", jsonLog["foo"])
-	assert.Equal(tester, 45.0, jsonLog["23"])
+	assert.InDelta(tester, 45.0, jsonLog["23"], 0.01)
 }
 
 func TestMergeMapEntries(tester *testing.T) {

exporter/prometheusexporter/accumulator_test.go

@@ -256,7 +256,7 @@ func TestAccumulateMetrics(t *testing.T) {
 				return true
 			})
 			require.Equal(t, m2Labels.Len(), vLabels.Len())
-			require.Equal(t, m2Value, vValue)
+			require.InDelta(t, m2Value, vValue, 0.01)
 			require.Equal(t, ts2.Unix(), vTS.Unix())
 			require.Greater(t, v.updated.Unix(), vTS.Unix())
 			require.Equal(t, m2Temporality, vTemporality)
@@ -280,7 +280,7 @@ func TestAccumulateMetrics(t *testing.T) {
 			v = m.(*accumulatedValue)
 			_, vTS, vValue, _, _ = getMetricProperties(v.value)
 
-			require.Equal(t, m3Value, vValue)
+			require.InDelta(t, m3Value, vValue, 0.01)
 			require.Equal(t, ts3.Unix(), vTS.Unix())
 		})
 	}
@@ -370,7 +370,7 @@ func TestAccumulateDeltaToCumulative(t *testing.T) {
 				return true
 			})
 			require.Equal(t, mLabels.Len(), vLabels.Len())
-			require.Equal(t, mValue, vValue)
+			require.InDelta(t, mValue, vValue, 0.01)
 			require.Equal(t, dataPointValue1+dataPointValue2, vValue)
 			require.Equal(t, pmetric.AggregationTemporalityCumulative, vTemporality)
 			require.True(t, vIsMonotonic)

internal/aws/containerinsight/utils_test.go

@@ -170,7 +170,7 @@ func checkMetricsAreExpected(t *testing.T, md pmetric.Metrics, fields map[string
 				dp := dps.At(0)
 				switch dp.ValueType() {
 				case pmetric.NumberDataPointValueTypeDouble:
-					assert.Equal(t, convertToFloat64(fields[metricName]), dp.DoubleValue())
+					assert.InDelta(t, convertToFloat64(fields[metricName]), dp.DoubleValue(), 0.01)
 				case pmetric.NumberDataPointValueTypeInt:
 					assert.Equal(t, convertToInt64(fields[metricName]), dp.IntValue())
 				}

internal/aws/metrics/metric_calculator_test.go

@@ -20,7 +20,7 @@ func TestFloat64RateCalculator(t *testing.T) {
 	c := newFloat64RateCalculator()
 	r, ok := c.Calculate(mKey, float64(50), initTime)
 	assert.False(t, ok)
-	assert.Equal(t, float64(0), r)
+	assert.InDelta(t, float64(0), r, 0.01)
 
 	nextTime := initTime.Add(100 * time.Millisecond)
 	r, ok = c.Calculate(mKey, float64(100), nextTime)
@@ -35,14 +35,14 @@ func TestFloat64RateCalculatorWithTooFrequentUpdate(t *testing.T) {
 	c := newFloat64RateCalculator()
 	r, ok := c.Calculate(mKey, float64(50), initTime)
 	assert.False(t, ok)
-	assert.Equal(t, float64(0), r)
+	assert.InDelta(t, float64(0), r, 0.01)
 
 	nextTime := initTime
 	for i := 0; i < 10; i++ {
 		nextTime = nextTime.Add(5 * time.Millisecond)
 		r, ok = c.Calculate(mKey, float64(105), nextTime)
 		assert.False(t, ok)
-		assert.Equal(t, float64(0), r)
+		assert.InDelta(t, float64(0), r, 0.01)
 	}
 
 	nextTime = nextTime.Add(5 * time.Millisecond)
@@ -75,7 +75,7 @@ func TestFloat64DeltaCalculator(t *testing.T) {
 		r, ok := c.Calculate(mKey, f, initTime)
 		assert.Equal(t, i > 0, ok)
 		if i == 0 {
-			assert.Equal(t, float64(0), r)
+			assert.InDelta(t, float64(0), r, 0.01)
 		} else {
 			assert.InDelta(t, f-testCases[i-1], r, f/10)
 		}

pkg/sampling/encoding_test.go

@@ -101,9 +101,9 @@ func TestInvalidprobabilityToTValue(t *testing.T) {
 }
 
 func TestTValueToProbability(t *testing.T) {
-	require.Equal(t, 0.5, must(tValueToProbability("8")))
-	require.Equal(t, 1-0x444p-12, must(tValueToProbability("444")))
-	require.Equal(t, 1.0, must(tValueToProbability("0")))
+	require.InDelta(t, 0.5, must(tValueToProbability("8")), 0.01)
+	require.InDelta(t, 1-0x444p-12, must(tValueToProbability("444")), 0.01)
+	require.InDelta(t, 1.0, must(tValueToProbability("0")), 0.01)
 
 	// 0x55555554p-32 is very close to 1/3
 	require.InEpsilon(t, 1-1/3., must(tValueToProbability("55555554")), 1e-9)

processor/cumulativetodeltaprocessor/internal/tracking/tracker_test.go

@@ -216,7 +216,7 @@ func TestMetricTracker_Convert(t *testing.T) {
 					if !ttt.noOut {
 						require.True(t, valid)
 						assert.Equal(t, ttt.wantOut.StartTimestamp, gotOut.StartTimestamp)
-						assert.Equal(t, ttt.wantOut.FloatValue, gotOut.FloatValue)
+						assert.InDelta(t, ttt.wantOut.FloatValue, gotOut.FloatValue, 0.01)
 					}
 
 					gotOut, valid = m.Convert(intPoint)

processor/cumulativetodeltaprocessor/processor_test.go

@@ -485,7 +485,7 @@ func TestCumulativeToDeltaProcessor(t *testing.T) {
 					require.Equal(t, eDataPoints.Len(), aDataPoints.Len())
 
 					for j := 0; j < eDataPoints.Len(); j++ {
-						require.Equal(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue())
+						require.InDelta(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue(), 0.01)
 					}
 				}
 
@@ -500,7 +500,7 @@ func TestCumulativeToDeltaProcessor(t *testing.T) {
 						if math.IsNaN(eDataPoints.At(j).DoubleValue()) {
 							assert.True(t, math.IsNaN(aDataPoints.At(j).DoubleValue()))
 						} else {
-							require.Equal(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue())
+							require.InDelta(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue(), 0.01)
 						}
 						require.Equal(t, eDataPoints.At(j).Flags(), aDataPoints.At(j).Flags())
 					}
@@ -521,7 +521,7 @@ func TestCumulativeToDeltaProcessor(t *testing.T) {
 						if math.IsNaN(eDataPoints.At(j).Sum()) {
 							require.True(t, math.IsNaN(aDataPoints.At(j).Sum()))
 						} else {
-							require.Equal(t, eDataPoints.At(j).Sum(), aDataPoints.At(j).Sum())
+							require.InDelta(t, eDataPoints.At(j).Sum(), aDataPoints.At(j).Sum(), 0.01)
 						}
 						require.Equal(t, eDataPoints.At(j).BucketCounts(), aDataPoints.At(j).BucketCounts())
 						require.Equal(t, eDataPoints.At(j).Flags(), aDataPoints.At(j).Flags())

processor/deltatorateprocessor/processor_test.go

@@ -157,7 +157,7 @@ func TestCumulativeToDeltaProcessor(t *testing.T) {
 					require.Equal(t, eDataPoints.Len(), aDataPoints.Len())
 
 					for j := 0; j < eDataPoints.Len(); j++ {
-						require.Equal(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue())
+						require.InDelta(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue(), 0.01)
 					}
 				}
 
@@ -169,7 +169,7 @@ func TestCumulativeToDeltaProcessor(t *testing.T) {
 					require.Equal(t, eM.Sum().AggregationTemporality(), aM.Sum().AggregationTemporality())
 
 					for j := 0; j < eDataPoints.Len(); j++ {
-						require.Equal(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue())
+						require.InDelta(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue(), 0.01)
 					}
 				}
 

processor/metricsgenerationprocessor/processor_test.go

@@ -314,7 +314,7 @@ func TestMetricsGenerationProcessor(t *testing.T) {
 					for j := 0; j < eDataPoints.Len(); j++ {
 						switch eDataPoints.At(j).ValueType() {
 						case pmetric.NumberDataPointValueTypeDouble:
-							require.Equal(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue())
+							require.InDelta(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue(), 0.01)
 						case pmetric.NumberDataPointValueTypeInt:
 							require.Equal(t, eDataPoints.At(j).IntValue(), aDataPoints.At(j).IntValue())
 						}

processor/remotetapprocessor/config_test.go

@@ -12,5 +12,5 @@ import (
 func TestCreateDefaultConfig(t *testing.T) {
 	cfg := createDefaultConfig().(*Config)
 	assert.Equal(t, "localhost:12001", cfg.Endpoint)
-	assert.EqualValues(t, 1, cfg.Limit)
+	assert.InDelta(t, 1, cfg.Limit, 0.01)
 }

processor/routingprocessor/metrics_test.go

@@ -468,7 +468,7 @@ func TestMetricsAreCorrectlySplitPerResourceAttributeRoutingWithOTTL(t *testing.
 		rmetric := defaultExp.AllMetrics()[0].ResourceMetrics().At(0)
 		attr, ok := rmetric.Resource().Attributes().Get("value")
 		assert.True(t, ok, "routing attribute must exists")
-		assert.Equal(t, attr.Double(), float64(-1.0))
+		assert.InDelta(t, attr.Double(), float64(-1.0), 0.01)
 	})
 }
 

receiver/awscontainerinsightreceiver/internal/k8sapiserver/k8sapiserver_test.go

@@ -125,7 +125,7 @@ func assertMetricValueEqual(t *testing.T, m pmetric.Metrics, metricName string,
 				if metric.Type() == pmetric.MetricTypeGauge {
 					switch metric.Gauge().DataPoints().At(0).ValueType() {
 					case pmetric.NumberDataPointValueTypeDouble:
-						assert.Equal(t, expected, metric.Gauge().DataPoints().At(0).DoubleValue())
+						assert.InDelta(t, expected, metric.Gauge().DataPoints().At(0).DoubleValue(), 0.01)
 					case pmetric.NumberDataPointValueTypeInt:
 						assert.Equal(t, expected, metric.Gauge().DataPoints().At(0).IntValue())
 					case pmetric.NumberDataPointValueTypeEmpty:

receiver/awscontainerinsightreceiver/internal/stores/podstore_test.go

@@ -220,9 +220,9 @@ func TestPodStore_decorateCpu(t *testing.T) {
 
 	assert.Equal(t, uint64(10), metric.GetField("pod_cpu_request").(uint64))
 	assert.Equal(t, uint64(10), metric.GetField("pod_cpu_limit").(uint64))
-	assert.Equal(t, float64(0.25), metric.GetField("pod_cpu_reserved_capacity").(float64))
-	assert.Equal(t, float64(10), metric.GetField("pod_cpu_utilization_over_pod_limit").(float64))
-	assert.Equal(t, float64(1), metric.GetField("pod_cpu_usage_total").(float64))
+	assert.InDelta(t, float64(0.25), metric.GetField("pod_cpu_reserved_capacity").(float64), 0.01)
+	assert.InDelta(t, float64(10), metric.GetField("pod_cpu_utilization_over_pod_limit").(float64), 0.01)
+	assert.InDelta(t, float64(1), metric.GetField("pod_cpu_usage_total").(float64), 0.01)
 
 	// test container metrics
 	tags = map[string]string{ci.MetricType: ci.TypeContainer, ci.ContainerNamekey: "ubuntu"}
@@ -232,7 +232,7 @@ func TestPodStore_decorateCpu(t *testing.T) {
 
 	assert.Equal(t, uint64(10), metric.GetField("container_cpu_request").(uint64))
 	assert.Equal(t, uint64(10), metric.GetField("container_cpu_limit").(uint64))
-	assert.Equal(t, float64(1), metric.GetField("container_cpu_usage_total").(float64))
+	assert.InDelta(t, float64(1), metric.GetField("container_cpu_usage_total").(float64), 0.01)
 }
 
 func TestPodStore_decorateMem(t *testing.T) {
@@ -248,8 +248,8 @@ func TestPodStore_decorateMem(t *testing.T) {
 
 	assert.Equal(t, uint64(52428800), metric.GetField("pod_memory_request").(uint64))
 	assert.Equal(t, uint64(52428800), metric.GetField("pod_memory_limit").(uint64))
-	assert.Equal(t, float64(12.5), metric.GetField("pod_memory_reserved_capacity").(float64))
-	assert.Equal(t, float64(20), metric.GetField("pod_memory_utilization_over_pod_limit").(float64))
+	assert.InDelta(t, float64(12.5), metric.GetField("pod_memory_reserved_capacity").(float64), 0.01)
+	assert.InDelta(t, float64(20), metric.GetField("pod_memory_utilization_over_pod_limit").(float64), 0.01)
 	assert.Equal(t, uint64(10*1024*1024), metric.GetField("pod_memory_working_set").(uint64))
 
 	tags = map[string]string{ci.MetricType: ci.TypeContainer, ci.ContainerNamekey: "ubuntu"}
@@ -260,7 +260,7 @@ func TestPodStore_decorateMem(t *testing.T) {
 
 	assert.Equal(t, uint64(52428800), metric.GetField("container_memory_request").(uint64))
 	assert.Equal(t, uint64(52428800), metric.GetField("container_memory_limit").(uint64))
-	assert.Equal(t, float64(10*1024*1024), metric.GetField("container_memory_working_set").(float64))
+	assert.InDelta(t, float64(10*1024*1024), metric.GetField("container_memory_working_set").(float64), 0.01)
 }
 
 func TestPodStore_addContainerCount(t *testing.T) {
@@ -613,7 +613,7 @@ func TestPodStore_decorateNode(t *testing.T) {
 	assert.Equal(t, uint64(10), metric.GetField("node_cpu_request").(uint64))
 	assert.Equal(t, uint64(4000), metric.GetField("node_cpu_limit").(uint64))
 	assert.Equal(t, float64(0.25), metric.GetField("node_cpu_reserved_capacity").(float64))
-	assert.Equal(t, float64(100), metric.GetField("node_cpu_usage_total").(float64))
+	assert.InDelta(t, float64(100), metric.GetField("node_cpu_usage_total").(float64), 0.01)
 
 	assert.Equal(t, uint64(50*1024*1024), metric.GetField("node_memory_request").(uint64))
 	assert.Equal(t, uint64(400*1024*1024), metric.GetField("node_memory_limit").(uint64))
@@ -649,7 +649,7 @@ func TestPodStore_decorateNode_multiplePodStates(t *testing.T) {
 	assert.Equal(t, uint64(0), metric.GetField("node_cpu_request").(uint64))
 	assert.Equal(t, uint64(4000), metric.GetField("node_cpu_limit").(uint64))
 	assert.Equal(t, float64(0), metric.GetField("node_cpu_reserved_capacity").(float64))
-	assert.Equal(t, float64(100), metric.GetField("node_cpu_usage_total").(float64))
+	assert.InDelta(t, float64(100), metric.GetField("node_cpu_usage_total").(float64), 0.01)
 
 	assert.Equal(t, uint64(0), metric.GetField("node_memory_request").(uint64))
 	assert.Equal(t, uint64(400*1024*1024), metric.GetField("node_memory_limit").(uint64))

receiver/hostmetricsreceiver/internal/scraper/loadscraper/load_scraper_windows_test.go

@@ -97,9 +97,9 @@ func TestSampleLoad(t *testing.T) {
 		samplerInstance.sampleLoad()
 	}
 
-	assert.Equal(t, calcExpectedLoad(counterReturnValues, loadAvgFactor1m), samplerInstance.loadAvg1m)
-	assert.Equal(t, calcExpectedLoad(counterReturnValues, loadAvgFactor5m), samplerInstance.loadAvg5m)
-	assert.Equal(t, calcExpectedLoad(counterReturnValues, loadAvgFactor15m), samplerInstance.loadAvg15m)
+	assert.InDelta(t, calcExpectedLoad(counterReturnValues, loadAvgFactor1m), samplerInstance.loadAvg1m, 0.01)
+	assert.InDelta(t, calcExpectedLoad(counterReturnValues, loadAvgFactor5m), samplerInstance.loadAvg5m, 0.01)
+	assert.InDelta(t, calcExpectedLoad(counterReturnValues, loadAvgFactor15m), samplerInstance.loadAvg15m, 0.01)
 }
 
 func calcExpectedLoad(scrapedValues []int64, loadAvgFactor float64) float64 {

receiver/prometheusreceiver/metrics_receiver_helper_test.go

@@ -340,7 +340,7 @@ func isFirstFailedScrape(metrics []pmetric.Metric, normalizedNames bool) bool {
 func assertUp(t *testing.T, expected float64, metrics []pmetric.Metric) {
 	for _, m := range metrics {
 		if m.Name() == "up" {
-			assert.Equal(t, expected, m.Gauge().DataPoints().At(0).DoubleValue()) // (assumed up will not have multiple datapoints)
+			assert.InDelta(t, expected, m.Gauge().DataPoints().At(0).DoubleValue(), 0.01) // (assumed up will not have multiple datapoints)
 			return
 		}
 	}
@@ -620,7 +620,7 @@ func compareSummaryStartTimestamp(timeStamp pcommon.Timestamp) summaryPointCompa
 
 func compareDoubleValue(doubleVal float64) numberPointComparator {
 	return func(t *testing.T, numberDataPoint pmetric.NumberDataPoint) {
-		assert.Equal(t, doubleVal, numberDataPoint.DoubleValue(), "Metric double value does not match")
+		assert.InDelta(t, doubleVal, numberDataPoint.DoubleValue(), 0.01, "Metric double value does not match")
 	}
 }
 
@@ -634,7 +634,7 @@ func assertNormalNan() numberPointComparator {
 func compareHistogram(count uint64, sum float64, upperBounds []float64, buckets []uint64) histogramPointComparator {
 	return func(t *testing.T, histogramDataPoint pmetric.HistogramDataPoint) {
 		assert.Equal(t, count, histogramDataPoint.Count(), "Histogram count value does not match")
-		assert.Equal(t, sum, histogramDataPoint.Sum(), "Histogram sum value does not match")
+		assert.InDelta(t, sum, histogramDataPoint.Sum(), 0.01, "Histogram sum value does not match")
 		assert.Equal(t, upperBounds, histogramDataPoint.ExplicitBounds().AsRaw(), "Histogram upper bounds values do not match")
 		assert.Equal(t, buckets, histogramDataPoint.BucketCounts().AsRaw(), "Histogram bucket count values do not match")
 	}