Fix MongoDB query heuristic semantics

client-java/controller/src/main/java/org/evomaster/client/java/controller/mongo/QueryParser.java

@@ -4,7 +4,9 @@
 import org.evomaster.client.java.controller.mongo.operations.QueryOperationWithField;
 import org.evomaster.client.java.controller.mongo.selectors.*;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -19,6 +21,10 @@
 public class QueryParser {
 
     private static final String SYNTHETIC_FIELD_NAME = "$";
+    private static final String COMMENT_OPERATOR = "$comment";
+    // "$comments" is not a real MongoDB operator: it is treated as noise/metadata to be
+    // stripped wherever it appears, unlike "$comment" which is the real comment operator.
+    private static final Set<String> COMMENTS_OPERATORS = new HashSet<>(Arrays.asList("$comments"));
 
     List<QuerySelector> selectors = Arrays.asList(
             new EqualsSelector(),
@@ -54,18 +60,76 @@ public QueryOperation parse(Object bsonDocument) {
             return null;
         }
 
-        QueryOperation operation = parseWithSelectors(bsonDocument);
+        // A document made up entirely of "$comments" noise, with nothing else to query on,
+        // does not represent any real condition.
+        if (isOnlyNoiseComments(bsonDocument)) {
+            return null;
+        }
+
+        // "$comments" is noise and gets stripped wherever it appears, however deeply nested,
+        // since it never carries query semantics. "$comment" is the real MongoDB operator: it
+        // only has meaning as a predicate-level key (this document's own keys), so it is
+        // stripped shallowly here and left untouched inside field values/literals (e.g. under
+        // an explicit $eq, or as the entire value of a field), where it must be compared as-is.
+        Object normalizedWithoutComments = removeTopLevelCommentOperator(removeCommentsOperators(bsonDocument));
+
+        QueryOperation operation = parseWithSelectors(normalizedWithoutComments);
         if (operation != null && !usesOperatorAsFieldName(operation)) {
             return operation;
         }
 
-        Object normalizedDocument = normalizeTopLevelValueOperatorQuery(bsonDocument);
-        if (normalizedDocument == bsonDocument) {
+        Object normalizedDocument = normalizeTopLevelValueOperatorQuery(normalizedWithoutComments);
+        if (normalizedDocument == normalizedWithoutComments) {
             return operation;
         }
         return parseWithSelectors(normalizedDocument);
     }
 
+    private boolean isOnlyNoiseComments(Object bsonDocument) {
+        if (!isBsonDocument(bsonDocument)) {
+            return false;
+        }
+        Set<String> keys = documentKeys(bsonDocument);
+        return keys != null && !keys.isEmpty() && keys.stream().allMatch(COMMENTS_OPERATORS::contains);
+    }
+
+    private Object removeTopLevelCommentOperator(Object bsonValue) {
+        if (!isBsonDocument(bsonValue)) {
+            return bsonValue;
+        }
+        Object normalized = newDocument(bsonValue);
+        for (String key : documentKeys(bsonValue)) {
+            if (key.equals(COMMENT_OPERATOR)) {
+                continue;
+            }
+            appendToDocument(normalized, key, getValue(bsonValue, key));
+        }
+        return normalized;
+    }
+
+    private Object removeCommentsOperators(Object bsonValue) {
+        if (isBsonDocument(bsonValue)) {
+            Object normalized = newDocument(bsonValue);
+            for (String key : documentKeys(bsonValue)) {
+                if (COMMENTS_OPERATORS.contains(key)) {
+                    continue;
+                }
+                appendToDocument(normalized, key, removeCommentsOperators(getValue(bsonValue, key)));
+            }
+            return normalized;
+        }
+
+        if (bsonValue instanceof List<?>) {
+            List<Object> normalized = new ArrayList<>();
+            for (Object item : (List<?>) bsonValue) {
+                normalized.add(removeCommentsOperators(item));
+            }
+            return normalized;
+        }
+
+        return bsonValue;
+    }
+
     private boolean usesOperatorAsFieldName(QueryOperation operation) {
         if (!(operation instanceof QueryOperationWithField)) {
             return false;

client-java/controller/src/main/java/org/evomaster/client/java/controller/mongo/operations/TrueOperation.java → client-java/controller/src/main/java/org/evomaster/client/java/controller/mongo/operations/EmptyOperation.java

@@ -5,9 +5,9 @@
  * This query matches all documents in a collection, effectively
  * returning all documents without any filtering.
  */
-public class TrueOperation  extends QueryOperation {
+public class EmptyOperation extends QueryOperation {
 
-    public TrueOperation() {
+    public EmptyOperation() {
 
     }
 }

client-java/controller/src/main/java/org/evomaster/client/java/controller/mongo/operations/RegexOptions.java

@@ -1,6 +1,7 @@
 package org.evomaster.client.java.controller.mongo.operations;
 
 import java.util.Objects;
+import java.util.regex.Pattern;
 
 /**
  * Options supported by MongoDB's {@code $regex} operator.
@@ -87,4 +88,30 @@ public boolean equals(Object other) {
     public int hashCode() {
         return Objects.hash(caseInsensitive, multiline, dotAll, extended, unicode);
     }
+
+    public int toJavaRegexFlags() {
+        int flags = 0;
+        if (isCaseInsensitive()) {
+            flags |= Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE;
+        }
+        if (isMultiline()) {
+            flags |= Pattern.MULTILINE;
+        }
+        if (isDotAll()) {
+            flags |= Pattern.DOTALL;
+        }
+        if (isExtended()) {
+            flags |= Pattern.COMMENTS;
+        }
+        if (isUnicode()) {
+            /**
+             * MongoDB's 'u' option is intentionally mapped to no Java regex flag.
+             * For MongoDB $regex, UTF mode is enabled by default, making 'u' redundant.
+             * Java regex operates on Unicode strings, so no equivalent Pattern flag is required.
+             */
+        }
+        return flags;
+    }
+
+
 }

client-java/controller/src/main/java/org/evomaster/client/java/controller/mongo/operations/TypeOperation.java

@@ -1,19 +1,33 @@
 package org.evomaster.client.java.controller.mongo.operations;
 
 
+import org.evomaster.client.java.controller.mongo.utils.BsonHelper;
+
+import java.util.List;
+import java.util.Objects;
+
 /**
  * Represent $type operation.
  * Selects documents where the value of the field is an instance of the specified BSON type(s).
  */
 public class TypeOperation extends QueryOperationWithField {
-    private final Object type;
+    private final List<Object> bsonTypes;
 
-    public TypeOperation(String fieldName, Object type) {
+    public TypeOperation(String fieldName, List<Object> bsonTypes) {
         super(fieldName);
-        this.type = type;
+        Objects.requireNonNull(bsonTypes);
+        if (bsonTypes.isEmpty()) {
+            throw new IllegalArgumentException("BSON types list cannot be empty");
+        }
+        for (Object type : bsonTypes) {
+            if (!BsonHelper.isBsonType(type)) {
+                throw new IllegalArgumentException("Invalid BSON type: " + type);
+            }
+        }
+        this.bsonTypes = bsonTypes;
     }
 
-    public Object getType() {
-        return type;
+    public List<Object> getBsonTypes() {
+        return bsonTypes;
     }
 }

client-java/controller/src/main/java/org/evomaster/client/java/controller/mongo/selectors/AllSelector.java

@@ -1,9 +1,16 @@
 package org.evomaster.client.java.controller.mongo.selectors;
 
+import org.evomaster.client.java.controller.mongo.QueryParser;
 import org.evomaster.client.java.controller.mongo.operations.*;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
+import java.util.Set;
+
+import static org.evomaster.client.java.controller.mongo.utils.BsonHelper.documentKeys;
+import static org.evomaster.client.java.controller.mongo.utils.BsonHelper.getValue;
+import static org.evomaster.client.java.controller.mongo.utils.BsonHelper.isBsonDocument;
 
 /**
  * Represents a selector for the MongoDB `$all` operator.
@@ -13,23 +20,50 @@
  * This operator matches arrays that contain all elements specified in the query.
  * The selector checks if the query value is a list and, if so, creates an
  * {@link AllOperation} object corresponding to the field and the list of values.
+ * Elements shaped as { $elemMatch: {...} } are a documented exception: rather than
+ * being compared for equality, they are parsed into an {@link ElemMatchOperation}
+ * that must be satisfied by some element of the array.
  */
 public class AllSelector extends SingleConditionQuerySelector {
 
     public static final String ALL_OPERATOR = "$all";
+    private static final String ELEM_MATCH_OPERATOR = "$elemMatch";
 
     @Override
     protected QueryOperation parseValue(String fieldName, Object value) {
         Objects.requireNonNull(fieldName);
         Objects.requireNonNull(value);
 
         if (value instanceof List<?>) {
-            return new AllOperation<>(fieldName, (List<?>) value);
+            List<Object> parsedValues = new ArrayList<>();
+            for (Object element : (List<?>) value) {
+                parsedValues.add(parseElement(fieldName, element));
+            }
+            return new AllOperation<>(fieldName, parsedValues);
         } else {
             return null;
         }
     }
 
+    private Object parseElement(String fieldName, Object element) {
+        if (!isBsonDocument(element)) {
+            return element;
+        }
+
+        Set<String> keys = documentKeys(element);
+        if (keys == null || keys.size() != 1 || !keys.contains(ELEM_MATCH_OPERATOR)) {
+            return element;
+        }
+
+        Object innerQuery = getValue(element, ELEM_MATCH_OPERATOR);
+        if (!isBsonDocument(innerQuery)) {
+            return element;
+        }
+
+        QueryOperation condition = new QueryParser().parse(innerQuery);
+        return condition == null ? element : new ElemMatchOperation(fieldName, condition);
+    }
+
     @Override
     protected String operator() {
         return ALL_OPERATOR;

client-java/controller/src/main/java/org/evomaster/client/java/controller/mongo/selectors/BitsAllClearSelector.java

@@ -2,8 +2,10 @@
 
 import org.evomaster.client.java.controller.mongo.operations.BitsAllClearOperation;
 import org.evomaster.client.java.controller.mongo.operations.QueryOperation;
+import org.evomaster.client.java.controller.mongo.utils.BitmaskUtils;
 
 import java.util.Objects;
+import java.util.OptionalLong;
 
 /**
  * { field: { $bitsAllClear: value } }
@@ -15,7 +17,8 @@ public class BitsAllClearSelector extends SingleConditionQuerySelector {
     @Override
     protected QueryOperation parseValue(String fieldName, Object value) {
         Objects.requireNonNull(fieldName);
-        return value instanceof Long ? new BitsAllClearOperation(fieldName, (Long) value) : null;
+        OptionalLong bitmaskValue = BitmaskUtils.toBitMaskValue(value);
+        return bitmaskValue.isPresent() ? new BitsAllClearOperation(fieldName, bitmaskValue.getAsLong()) : null;
     }
 
     @Override

client-java/controller/src/main/java/org/evomaster/client/java/controller/mongo/selectors/BitsAllSetSelector.java

@@ -2,8 +2,10 @@
 
 import org.evomaster.client.java.controller.mongo.operations.BitsAllSetOperation;
 import org.evomaster.client.java.controller.mongo.operations.QueryOperation;
+import org.evomaster.client.java.controller.mongo.utils.BitmaskUtils;
 
 import java.util.Objects;
+import java.util.OptionalLong;
 
 /**
  * { field: { $bitsAllSet: value } }
@@ -15,7 +17,8 @@ public class BitsAllSetSelector extends SingleConditionQuerySelector {
     @Override
     protected QueryOperation parseValue(String fieldName, Object value) {
         Objects.requireNonNull(fieldName);
-        return value instanceof Long ? new BitsAllSetOperation(fieldName, (Long) value) : null;
+        OptionalLong bitmaskValue = BitmaskUtils.toBitMaskValue(value);
+        return bitmaskValue.isPresent() ? new BitsAllSetOperation(fieldName, bitmaskValue.getAsLong()) : null;
     }
 
     @Override

client-java/controller/src/main/java/org/evomaster/client/java/controller/mongo/selectors/BitsAnyClearSelector.java

@@ -2,8 +2,10 @@
 
 import org.evomaster.client.java.controller.mongo.operations.BitsAnyClearOperation;
 import org.evomaster.client.java.controller.mongo.operations.QueryOperation;
+import org.evomaster.client.java.controller.mongo.utils.BitmaskUtils;
 
 import java.util.Objects;
+import java.util.OptionalLong;
 
 /**
  * { field: { $bitsAnyClear: value } }
@@ -15,7 +17,8 @@ public class BitsAnyClearSelector extends SingleConditionQuerySelector {
     @Override
     protected QueryOperation parseValue(String fieldName, Object value) {
         Objects.requireNonNull(fieldName);
-        return value instanceof Long ? new BitsAnyClearOperation(fieldName, (Long) value) : null;
+        OptionalLong bitmaskValue = BitmaskUtils.toBitMaskValue(value);
+        return bitmaskValue.isPresent() ? new BitsAnyClearOperation(fieldName, bitmaskValue.getAsLong()) : null;
     }
 
     @Override

client-java/controller/src/main/java/org/evomaster/client/java/controller/mongo/selectors/BitsAnySetSelector.java

@@ -2,8 +2,11 @@
 
 import org.evomaster.client.java.controller.mongo.operations.BitsAnySetOperation;
 import org.evomaster.client.java.controller.mongo.operations.QueryOperation;
+import org.evomaster.client.java.controller.mongo.utils.BitmaskUtils;
 
+import java.util.List;
 import java.util.Objects;
+import java.util.OptionalLong;
 
 /**
  * { field: { $bitsAnySet: value } }
@@ -15,9 +18,11 @@ public class BitsAnySetSelector extends SingleConditionQuerySelector {
     @Override
     protected QueryOperation parseValue(String fieldName, Object value) {
         Objects.requireNonNull(fieldName);
-        return value instanceof Long ? new BitsAnySetOperation(fieldName, (Long) value) : null;
+        OptionalLong bitmaskValue = BitmaskUtils.toBitMaskValue(value);
+        return bitmaskValue.isPresent() ? new BitsAnySetOperation(fieldName, bitmaskValue.getAsLong()) : null;
     }
 
+
     @Override
     protected String operator() {
         return BITS_ANY_SET_OPERATOR;