Fix flaky TPC-H Q1 test due to bugs in MatcherUtils.closeTo() (#5283)

* Fix the flaky tpch Q1

Signed-off-by: Lantao Jin <ltjin@amazon.com>

* Change to ULP-aware to handle floating-point precision differences

Signed-off-by: Lantao Jin <ltjin@amazon.com>

---------

Signed-off-by: Lantao Jin <ltjin@amazon.com>
(cherry picked from commit 246ed0d)
Signed-off-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: github-actions[bot]

integ-test/src/test/java/org/opensearch/sql/util/MatcherUtils.java

@@ -42,6 +42,12 @@
 
 public class MatcherUtils {
 
+  /** Absolute tolerance floor for {@link #closeTo} numeric comparisons. */
+  private static final double ABSOLUTE_TOLERANCE = 1e-10;
+
+  /** Number of ULPs tolerated by {@link #closeTo} to absorb platform-dependent rounding. */
+  private static final int ULP_TOLERANCE_FACTOR = 4;
+
   private static final Logger LOG = LogManager.getLogger();
   private static final ObjectMapper JSON_MAPPER = new ObjectMapper();
 
@@ -302,29 +308,44 @@ protected boolean matchesSafely(JSONArray array) {
   }
 
   public static TypeSafeMatcher<JSONArray> closeTo(Object... values) {
-    final double error = 1e-10;
     return new TypeSafeMatcher<JSONArray>() {
       @Override
       protected boolean matchesSafely(JSONArray item) {
         List<Object> expectedValues = new ArrayList<>(Arrays.asList(values));
         List<Object> actualValues = new ArrayList<>();
         item.iterator().forEachRemaining(v -> actualValues.add((Object) v));
-        return actualValues.stream()
-            .allMatch(
-                v ->
-                    v instanceof Number
-                        ? valuesAreClose(
-                            (Number) v, (Number) expectedValues.get(actualValues.indexOf(v)))
-                        : v.equals(expectedValues.get(actualValues.indexOf(v))));
+        if (actualValues.size() != expectedValues.size()) {
+          return false;
+        }
+        for (int i = 0; i < actualValues.size(); i++) {
+          Object actual = actualValues.get(i);
+          Object expected = expectedValues.get(i);
+          if (actual instanceof Number && expected instanceof Number) {
+            if (!valuesAreClose((Number) actual, (Number) expected)) {
+              return false;
+            }
+          } else if (!actual.equals(expected)) {
+            return false;
+          }
+        }
+        return true;
       }
 
       @Override
       public void describeTo(Description description) {
         description.appendText(Arrays.toString(values));
       }
 
+      /**
+       * ULP-aware comparison: tolerates up to {@link #ULP_TOLERANCE_FACTOR} ULPs or {@link
+       * #ABSOLUTE_TOLERANCE}, whichever is larger.
+       */
       private boolean valuesAreClose(Number v1, Number v2) {
-        return Math.abs(v1.doubleValue() - v2.doubleValue()) <= error;
+        double d1 = v1.doubleValue();
+        double d2 = v2.doubleValue();
+        double diff = Math.abs(d1 - d2);
+        double ulpTolerance = ULP_TOLERANCE_FACTOR * Math.max(Math.ulp(d1), Math.ulp(d2));
+        return diff <= Math.max(ABSOLUTE_TOLERANCE, ulpTolerance);
       }
     };
   }