some small changes based on the PR review

Lamine Idjeraoui · andrross · commit 321fb54e0052 · 2025-11-21T14:21:01.000-08:00
Signed-off-by: Lamine Idjeraoui &lt;lidjeraoui@apple.com&gt;
diff --git a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/Assertion.java b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/Assertion.java
@@ -92,9 +92,9 @@ static Object convertActualValue(Object actualValue, Object expectedValue) {
                 return Double.parseDouble(actualValue.toString());
             } else if (expectedValue instanceof Integer) {
                 try {
-                    return Integer.parseInt(actualValue.toString());
-                } catch (NumberFormatException e) {
                     return Long.parseLong(actualValue.toString());
+                } catch (NumberFormatException e) {
+                    return Integer.parseInt(actualValue.toString());
                 }
             } else if (expectedValue instanceof Long) {
                 return Long.parseLong(actualValue.toString());
diff --git a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/GreaterThanAssertion.java b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/GreaterThanAssertion.java
@@ -43,7 +43,7 @@
  */
 public class GreaterThanAssertion extends OrderingAssertion {
     public static GreaterThanAssertion parse(XContentParser parser) throws IOException {
-        return parseCommon(parser, "gt", GreaterThanAssertion::new);
+        return parseOrderingAssertion(parser, Relation.GT, GreaterThanAssertion::new);
     }
 
     public GreaterThanAssertion(XContentLocation loc, String field, Object expected) {
diff --git a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/GreaterThanEqualToAssertion.java b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/GreaterThanEqualToAssertion.java
@@ -44,7 +44,7 @@
  */
 public class GreaterThanEqualToAssertion extends OrderingAssertion {
     public static GreaterThanEqualToAssertion parse(XContentParser parser) throws IOException {
-        return parseCommon(parser, "gte", GreaterThanEqualToAssertion::new);
+        return parseOrderingAssertion(parser, Relation.GTE, GreaterThanEqualToAssertion::new);
     }
 
     public GreaterThanEqualToAssertion(XContentLocation loc, String field, Object expected) {
diff --git a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/LessThanAssertion.java b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/LessThanAssertion.java
@@ -44,7 +44,7 @@
  */
 public class LessThanAssertion extends OrderingAssertion {
     public static LessThanAssertion parse(XContentParser parser) throws IOException {
-        return parseCommon(parser, "lt", LessThanAssertion::new);
+        return parseOrderingAssertion(parser, Relation.LT, LessThanAssertion::new);
     }
 
     public LessThanAssertion(XContentLocation loc, String field, Object expected) {
diff --git a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/LessThanOrEqualToAssertion.java b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/LessThanOrEqualToAssertion.java
@@ -44,7 +44,7 @@
  */
 public class LessThanOrEqualToAssertion extends OrderingAssertion {
     public static LessThanOrEqualToAssertion parse(XContentParser parser) throws IOException {
-        return parseCommon(parser, "lte", LessThanOrEqualToAssertion::new);
+        return parseOrderingAssertion(parser, Relation.LTE, LessThanOrEqualToAssertion::new);
     }
 
     public LessThanOrEqualToAssertion(XContentLocation loc, String field, Object expected) {
diff --git a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/OrderingAssertion.java b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/OrderingAssertion.java
@@ -23,7 +23,7 @@
 /**
  * Base class for all ordering assertions (gt/gte/lt/lte).
  * It provides:
- *  - shared YAML parse boilerplate (via {@link #parseCommon})
+ *  - shared YAML parse boilerplate (via {@link #parseOrderingAssertion})
  *  - numeric normalization so both sides are Comparable of the same class
  *  - common comparison logic based on a {@link Relation}
  */
@@ -53,14 +53,17 @@ protected interface OrderingAssertionFactory<T extends OrderingAssertion> {
     /**
      * Common parser for {gt|gte|lt|lte}: { field: expectedValue }
      */
-    protected static <T extends OrderingAssertion> T parseCommon(XContentParser parser, String sectionName, OrderingAssertionFactory<T> factory)
-        throws IOException {
+    protected static <T extends OrderingAssertion> T parseOrderingAssertion(
+        XContentParser parser,
+        Relation relation,
+        OrderingAssertionFactory<T> factory
+    ) throws IOException {
         XContentLocation location = parser.getTokenLocation();
         Tuple<String, Object> t = ParserUtils.parseTuple(parser);
         Object expected = t.v2();
         if (!(expected instanceof Comparable)) {
             throw new IllegalArgumentException(
-                sectionName
+                relation
                     + " section can only be used with objects that support natural ordering, found "
                     + expected.getClass().getSimpleName()
             );
@@ -122,28 +125,14 @@ private static String relationToString(Relation r) {
      *  - Else return as-is (let Comparable semantics handle it).
      */
     private static Tuple<Object, Object> normalizePair(Object a, Object b) {
-        if (a instanceof Number && b instanceof Number) {
-            boolean floaty = (a instanceof Float) || (a instanceof Double) || (b instanceof Float) || (b instanceof Double);
-            if (floaty) {
-                return Tuple.tuple(asDouble(a), asDouble(b));
+        if (a instanceof Number aNum && b instanceof Number bNum) {
+            boolean isFloating = aNum instanceof Float || aNum instanceof Double || bNum instanceof Float || bNum instanceof Double;
+            if (isFloating) {
+                return Tuple.tuple(aNum.doubleValue(), bNum.doubleValue());
             } else {
-                return Tuple.tuple(asLong(a), asLong(b));
+                return Tuple.tuple(aNum.longValue(), bNum.longValue());
             }
         }
         return Tuple.tuple(a, b);
     }
-
-    private static Double asDouble(Object n) {
-        if (n instanceof Number) {
-            return ((Number) n).doubleValue();
-        }
-        return Double.parseDouble(n.toString());
-    }
-
-    private static Long asLong(Object n) {
-        if (n instanceof Number) {
-            return ((Number) n).longValue();
-        }
-        return Long.parseLong(n.toString());
-    }
 }

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@`
`43`	`43`	`*/`
`44`	`44`	`public class GreaterThanAssertion extends OrderingAssertion {`
`45`	`45`	`public static GreaterThanAssertion parse(XContentParser parser) throws IOException {`
`46`		`- return parseCommon(parser, "gt", GreaterThanAssertion::new);`
	`46`	`+ return parseOrderingAssertion(parser, Relation.GT, GreaterThanAssertion::new);`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`public GreaterThanAssertion(XContentLocation loc, String field, Object expected) {`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@`
`44`	`44`	`*/`
`45`	`45`	`public class GreaterThanEqualToAssertion extends OrderingAssertion {`
`46`	`46`	`public static GreaterThanEqualToAssertion parse(XContentParser parser) throws IOException {`
`47`		`- return parseCommon(parser, "gte", GreaterThanEqualToAssertion::new);`
	`47`	`+ return parseOrderingAssertion(parser, Relation.GTE, GreaterThanEqualToAssertion::new);`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`public GreaterThanEqualToAssertion(XContentLocation loc, String field, Object expected) {`