Add an error margin when comparing floats.

Author: gmarouli

muted-tests.yml

@@ -541,15 +541,6 @@ tests:
 - class: org.elasticsearch.xpack.esql.qa.multi_node.EsqlSpecIT
   method: test {knn-function.KnnSearchWithKOption SYNC}
   issue: https://github.com/elastic/elasticsearch/issues/129512
-- class: org.elasticsearch.xpack.logsdb.qa.StandardVersusStandardReindexedIntoLogsDbChallengeRestIT
-  method: testMatchAllQuery
-  issue: https://github.com/elastic/elasticsearch/issues/129527
-- class: org.elasticsearch.xpack.logsdb.qa.BulkChallengeRestIT
-  method: testMatchAllQuery
-  issue: https://github.com/elastic/elasticsearch/issues/129528
-- class: org.elasticsearch.xpack.logsdb.qa.StoredSourceLogsDbVersusReindexedLogsDbChallengeRestIT
-  method: testMatchAllQuery
-  issue: https://github.com/elastic/elasticsearch/issues/129529
 - class: org.elasticsearch.index.engine.ThreadPoolMergeExecutorServiceTests
   method: testIORateIsAdjustedForAllRunningMergeTasks
   issue: https://github.com/elastic/elasticsearch/issues/129531

test/framework/src/main/java/org/elasticsearch/datageneration/matchers/source/DynamicFieldMatcher.java

@@ -17,9 +17,8 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.Set;
 import java.util.function.Function;
-import java.util.stream.Collectors;
+import java.util.function.Supplier;
 
 import static org.elasticsearch.datageneration.matchers.Messages.formatErrorMessage;
 import static org.elasticsearch.datageneration.matchers.Messages.prettyPrintCollections;
@@ -62,31 +61,46 @@ public MatchResult match(List<Object> actual, List<Object> expected) {
 
             var normalizedActual = normalizeDoubles(actual);
             var normalizedExpected = normalizeDoubles(expected);
+            Supplier<MatchResult> noMatchSupplier = () -> MatchResult.noMatch(
+                formatErrorMessage(
+                    actualMappings,
+                    actualSettings,
+                    expectedMappings,
+                    expectedSettings,
+                    "Values of dynamically mapped field containing double values don't match after normalization, normalized "
+                        + prettyPrintCollections(normalizedActual, normalizedExpected)
+                )
+            );
 
-            return normalizedActual.equals(normalizedExpected)
-                ? MatchResult.match()
-                : MatchResult.noMatch(
-                    formatErrorMessage(
-                        actualMappings,
-                        actualSettings,
-                        expectedMappings,
-                        expectedSettings,
-                        "Values of dynamically mapped field containing double values don't match after normalization, normalized "
-                            + prettyPrintCollections(normalizedActual, normalizedExpected)
-                    )
-                );
+            if (normalizedActual.size() != normalizedExpected.size()) {
+                return noMatchSupplier.get();
+            }
+
+            for (int i = 0; i < normalizedActual.size(); i++) {
+                if (floatsEquals(normalizedActual.get(i), normalizedExpected.get(i))) {
+                    return noMatchSupplier.get();
+                }
+            }
+
+            return MatchResult.match();
         }
 
         return matchWithGenericMatcher(actual, expected);
     }
 
-    private static Set<Float> normalizeDoubles(List<Object> values) {
+    private static List<Float> normalizeDoubles(List<Object> values) {
         if (values == null) {
-            return Set.of();
+            return List.of();
         }
 
         Function<Object, Float> toFloat = (o) -> o instanceof Number n ? n.floatValue() : Float.parseFloat((String) o);
-        return values.stream().filter(Objects::nonNull).map(toFloat).collect(Collectors.toSet());
+
+        // We skip nulls because they trip the pretty print collections.
+        return values.stream().filter(Objects::nonNull).map(toFloat).toList();
+    }
+
+    private static boolean floatsEquals(Float actual, Float expected) {
+        return Math.abs(actual - expected) > 1e-8;
     }
 
     private MatchResult matchWithGenericMatcher(List<Object> actualValues, List<Object> expectedValues) {