minor updates

Author: omursahin

core/src/main/kotlin/org/evomaster/core/output/formatter/OutputFormatter.kt

@@ -74,6 +74,9 @@ abstract class OutputFormatter (val name: String) {
                     if (!node.isObject) return null
                     fieldNames.mapNotNull { field ->
                         val value = node.get(field) ?: return@mapNotNull null
+                        // JSON null is reported as field-absent so callers cannot confuse
+                        // it with the literal 4-char string "null" (asText() collapses both).
+                        if (value.isNull) return@mapNotNull null
                         field to value.asText()
                     }.toMap()
                 } catch (e: Exception) {

core/src/main/kotlin/org/evomaster/core/problem/rest/oracle/HttpSemanticsOracle.kt

@@ -286,6 +286,8 @@ object HttpSemanticsOracle {
         if (!StatusGroup.G_2xx.isInGroup(resGet.getStatusCode())) return false
 
         val bodyParam = put.parameters.find { it is BodyParam } as BodyParam?
+
+        //for now we only deal with JSON/XML/FORM
         if (bodyParam != null && !bodyParam.isJson() && !bodyParam.isXml() && !bodyParam.isForm()) {
             return false
         }
@@ -294,8 +296,10 @@ object HttpSemanticsOracle {
         val getBody = resGet.getBody()
 
         // PUT sent content but GET body is empty -> sent fields definitely missing
-        if (!putBody.isNullOrEmpty() && getBody.isNullOrEmpty()) return true
-        if (getBody.isNullOrEmpty()) return false
+        if (getBody.isNullOrEmpty()) {
+            return !putBody.isNullOrEmpty()
+        }
+
 
         val sentFields = extractSentFieldNames(put)
         val allPutSchemaFields = extractModifiedFieldNames(put).ifEmpty {
@@ -390,7 +394,7 @@ object HttpSemanticsOracle {
         if (wipedFields.isNotEmpty()) {
             val getWiped = readGetFields(getBody, wipedFields) ?: return false
             for (field in wipedFields) {
-                if (isWipedFieldStillPresent(getWiped[field])) return true
+                if (!getWiped[field].isNullOrEmpty()) return true
             }
         }
 
@@ -430,16 +434,6 @@ object HttpSemanticsOracle {
             ?: OutputFormatter.XML_FORMATTER.readFields(getBody, fieldNames)
     }
 
-    /**
-     * A wiped field is present only if the GET response returns a non-null, non-empty value.
-     */
-    private fun isWipedFieldStillPresent(value: String?): Boolean {
-        if (value == null) return false
-        if (value.isEmpty()) return false
-        if (value == "null") return false
-        return true
-    }
-
     /**
      * Extract field names from the PUT/PATCH request body.
      * These are the fields that the client attempted to modify.
@@ -451,7 +445,9 @@ object HttpSemanticsOracle {
         return objectGene.fields.map { it.name }.toSet()
     }
 
-    // Extract only the field names that were actually sent in the request body.
+    /**
+    *  Extract only the field names that were actually sent in the request body.
+    */
     private fun extractSentFieldNames(modify: RestCallAction): Set<String> {
 
         val objectGene = extractBodyObjectGene(modify) ?: return emptySet()

core/src/test/kotlin/org/evomaster/core/problem/rest/oracle/HttpSemanticsOracleTest.kt

@@ -580,6 +580,40 @@ class HttpSemanticsOracleTest {
         assertTrue(mismatch)
     }
 
+    @Test
+    fun testPut_changedField_StringNull_returnsFalse() {
+        // PUT and GET both carry the literal 4-char string "null" for "name".
+        // Sent-fields path: values are equal, so no mismatch is reported.
+        val mismatch = runMismatchedPutOracle(
+            path = "/users",
+            putBody = jsonPutBodyParam(activeFields = mapOf("name" to "null")),
+            getResponseBody = """{"name":"null"}"""
+        )
+        assertFalse(mismatch)
+    }
+
+    @Test
+    fun testPut_wipedField_StringNullInGet_returnsTrue() {
+        // PUT omits "role" (full replacement should wipe it).
+        // GET returns the literal 4-char string "null" - the field still holds
+        // a real value, distinct from JSON null.
+        val schema = buildUsersSchema(
+            putWritable = listOf("name", "role"),
+            getResponseFields = listOf("name", "role")
+        )
+        val mismatch = runMismatchedPutOracle(
+            path = "/users",
+            putBody = jsonPutBodyParam(
+                activeFields = mapOf("name" to "Alice"),
+                omittedFields = setOf("role")
+            ),
+            getResponseBody = """{"name":"Alice","role":"null"}""",
+            schema = schema
+        )
+        assertTrue(mismatch)
+    }
+
+
     @Test
     fun testPut_writeOnlyFieldNotInGetSchema_noFalsePositive() {
         // password is in PUT schema but NOT in GET schema (write-only).
@@ -623,6 +657,7 @@ class HttpSemanticsOracleTest {
         assertTrue(mismatch)
     }
 
+
     @Test
     fun testPut_allFieldsOmitted_getReturnsOnlyReadOnlySchemaFields_returnsFalse() {
         val schema = buildUsersSchema(