[#212-REVUE] Implement standard tests for Canonical RDF into Corese-W3C

Author: abdessamad-abdoun

src/main/java/fr/inria/corese/core/next/api/base/model/AbstractIRI.java

@@ -22,9 +22,6 @@ public abstract class AbstractIRI implements IRI, Comparable<IRI> {
      * @throws IncorrectFormatException if the IRI format is incorrect
      */
     protected AbstractIRI(String fullIRI) {
-        if (fullIRI == null) {
-            throw new IllegalArgumentException("fullIRI cannot be null");
-        }
         if (!IRIUtils.isStandardIRI(fullIRI)) {
             throw new IncorrectFormatException("IRI '" + fullIRI + "' must be a valid IRI");
         }

src/main/java/fr/inria/corese/core/next/impl/common/util/IRIUtils.java

@@ -9,13 +9,14 @@
 
 /**
  * Utility class for IRI.
- *
+ * <p>
  * Intended to facilitate string manipulation related to IRI.
  */
 public class IRIUtils {
 
     private static final Pattern IRI_PATTERN = Pattern.compile("^(?<namespace>(?<protocol>[\\w\\-]+):(?<dblSlashes>\\/\\/)?(?<domain>([\\w\\-_:@]+\\.)*[\\w\\-_:]*))((?<path>\\/([\\w\\-\\._\\:]+\\/)*)(?<finalPath>[\\w\\-\\._\\:]+)?(?<query>\\?[\\w\\-_\\:\\?\\=]+)?(\\#)?(?<fragment>([\\w\\-_]+))?)?$");
     private static final Pattern STANDARD_IRI_PATTERN = Pattern.compile("^(([^:/?#\\s]+):)(\\/\\/([^/?#\\s]*))?([^?#\\s]*)(\\?([^#\\s]*))?(#(.*))?");
+    private static final Pattern RELATIVE_IRI_PATTERN = Pattern.compile("^[^\\s\\p{Cc}]+$");
     private static final int MAX_IRI_LENGTH = 2048;
     private static final long REGEX_TIMEOUT_MS = 100;
 
@@ -28,6 +29,7 @@ private IRIUtils() {
 
     /**
      * Guesses the namespace of an IRI using a regex pattern.
+     *
      * @param iri The IRI string to be processed.
      * @return the guessed namespace of the IRI or an empty string if no match is found.
      */
@@ -38,21 +40,22 @@ public static String guessNamespace(String iri) {
         try {
             Matcher matcher = matchWithTimeout(IRI_PATTERN, iri);
             if (matcher == null || !matcher.matches()) {
-                return "";
+                return iri.endsWith("#") ? iri : (iri.contains("#") ? iri.substring(0, iri.lastIndexOf("#") + 1) : iri);
+
             } else if (matcher.matches()) {
                 if (matcher.group("protocol") != null && matcher.group("protocol").equals("_")) {
                     return "";
                 }
                 StringBuilder namespace = new StringBuilder();
                 namespace.append(matcher.group("protocol")).append(":");
-                if(matcher.group("dblSlashes") != null) {
+                if (matcher.group("dblSlashes") != null) {
                     namespace.append(matcher.group("dblSlashes"));
                 }
                 namespace.append(matcher.group("domain"));
-                if(matcher.group("path") != null) {
+                if (matcher.group("path") != null) {
                     namespace.append(matcher.group("path"));
                 }
-                if(matcher.group("fragment") != null && matcher.group("finalPath") != null) {
+                if (matcher.group("fragment") != null && matcher.group("finalPath") != null) {
                     namespace.append(matcher.group("finalPath")).append("#");
                 }
                 return namespace.toString();
@@ -66,6 +69,7 @@ public static String guessNamespace(String iri) {
 
     /**
      * Guesses the local name of an IRI using a regex pattern.
+     *
      * @param iri The IRI string to be processed.
      * @return the guessed local name of the IRI or an empty string if no match is found.
      */
@@ -76,11 +80,11 @@ public static String guessLocalName(String iri) {
         try {
             Matcher matcher = matchWithTimeout(IRI_PATTERN, iri);
             if (matcher == null || !matcher.matches()) {
-                return "";
+                return iri;
             } else if (matcher.matches()) {
-                if(matcher.group("fragment") != null){ // If the IRI has a fragment
+                if (matcher.group("fragment") != null) { // If the IRI has a fragment
                     return matcher.group("fragment");
-                } else if(matcher.group("finalPath") != null ) { // If the IRI has no fragment but do not ends with a slash
+                } else if (matcher.group("finalPath") != null) { // If the IRI has no fragment but do not ends with a slash
                     return matcher.group("finalPath");
                 } else { // If the URI ends with a slash
                     return "";
@@ -95,6 +99,8 @@ public static String guessLocalName(String iri) {
 
     /**
      * Checks if the given string is a valid IRI using a regex pattern extracted from the W3C standards.
+     * Removes leading/trailing whitespace and non-breaking spaces before validation.
+     *
      * @param iriString The string to be checked.
      * @return true if the string is a valid IRI, false otherwise.
      */
@@ -103,7 +109,49 @@ public static boolean isStandardIRI(String iriString) {
             return false;
         }
 
+        // Remove leading whitespace and U+00A0 (non-breaking space)
+        int start = 0;
+        while (start < iriString.length()) {
+            char c = iriString.charAt(start);
+            if (Character.isWhitespace(c) || c == '\u00A0' || c == 160) {
+                start++;
+            } else {
+                break;
+            }
+        }
+
+        // Remove trailing whitespace and U+00A0 (non-breaking space)
+        int end = iriString.length();
+        while (end > start) {
+            char c = iriString.charAt(end - 1);
+            if (Character.isWhitespace(c) || c == '\u00A0' || c == 160) {
+                end--;
+            } else {
+                break;
+            }
+        }
+
+        iriString = iriString.substring(start, end);
+
+        if (iriString.isEmpty()) {
+            return false;
+        }
+
+        // Reject IRIs with internal whitespace
+        for (char c : iriString.toCharArray()) {
+            if (Character.isWhitespace(c) || c == '\u00A0' || c == 160) {
+                return false;
+            }
+        }
+
         try {
+            // If no scheme (no :), treat as relative IRI
+            if (!iriString.contains(":") || iriString.startsWith("#")) {
+                Matcher matcher = matchWithTimeout(RELATIVE_IRI_PATTERN, iriString);
+                return matcher != null && matcher.matches();
+            }
+
+            // If scheme present, validate as absolute IRI
             Matcher matcher = matchWithTimeout(STANDARD_IRI_PATTERN, iriString);
             if (matcher != null && matcher.matches()) {
                 return isValidURI(iriString);
@@ -114,6 +162,7 @@ public static boolean isStandardIRI(String iriString) {
         }
     }
 
+
     /**
      * Executes regex matching with timeout protection.
      */

src/test/java/fr/inria/corese/core/next/impl/common/util/IRIUtilsTest.java

@@ -23,8 +23,8 @@ public class IRIUtilsTest {
 
     // Array of strings that should be recognized as correct IRIs. Some of them taken from the official IRI documentation.
     private static final String[] correctARIs = { uriSchema, uriWithFragment, uriWithQuery, uriWithPort, uriWithPortAndQuery, uriWithPortAndQueryAndFragment, uriWithPortAndFragment, uriToHTMLPage, uriToHTMLPageWithQuery, uriToHTMLPageWithQueryAndFragment, uriToHTMLPageWithFragment, "ftp://ftp.is.co.za/rfc/rfc1808.txt", "http://www.ietf.org/rfc/rfc2396.txt", "ldap://[2001:db8::7]/c=GB?objectClass?one", "mailto:John.Doe@example.com", "news:comp.infosystems.www.servers.unix", "tel:+1-816-555-1212", "telnet://192.0.2.16:80/", "urn:oasis:names:specification:docbook:dtd:xml:4.1.2", "http://foo.co.uk/", "http://regexr.com/foo.html?q=bar" };
-    private static final String[] incorrectIRIs = { "0123456789 +-.,!@#$%^&*();\\\\/|<>\\\"\\'", "12345 -98.7 3.141 .6180 9,000 +42", "555.123.4567\t+1-(800)-555-2468", "foodemo.net", "bar.ba.test.co.uk", "www.demo.com", "g.com", "g-.com", "com.g", "-g.com", "xn--d1ai6ai.xn--p1ai", "xn-fsqu00a.xn-0zwm56d", "xn--stackoverflow.com", "stackoverflow.xn--com", "stackoverflow.co.uk", "google.com.au", "-0-0o.com", "0-0o_.com" };
-
+    private static final String[] incorrectIRIs = {"0123456789 +-.,!@#$%^&*()","12345 -98.7 3.141","555.123.4567\t+1-(800)","test\nstring","test\rstring","test\u0000string","   ","\u00A0","","  \t  ",                      // Only whitespace
+     };
     @Test
     public void guessNamespaceTest() {
         assertEquals("http://schema.org/test/test/", IRIUtils.guessNamespace(uriSchema));
@@ -63,8 +63,24 @@ public void isStandardIRITest() {
             assertTrue(IRIUtils.isStandardIRI(iri));
         }
         for (String iri : incorrectIRIs) {
-            assertFalse(IRIUtils.isStandardIRI(iri));
+            assertFalse(IRIUtils.isStandardIRI(iri), "Expected '" + escapeForDisplay(iri) + "' to be an invalid IRI");
         }
     }
 
+    /**
+     * Helper method to escape strings for display in test failure messages
+     */
+    private static String escapeForDisplay(String str) {
+        StringBuilder sb = new StringBuilder();
+        for (char c : str.toCharArray()) {
+            if (c < 0x20 || (c >= 0x7F && c <= 0x9F)) {
+                sb.append(String.format("\\u%04X", (int) c));
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+
+
 }

src/test/java/fr/inria/corese/core/next/impl/temp/CoreseIRITest.java

@@ -67,7 +67,15 @@ public void constructorCoreseNodeTest() {
 
     @Test
     public void constructorStringException() {
-        assertThrows(IncorrectFormatException.class, () -> new CoreseIRI("test"));
+
+        assertThrows(IncorrectFormatException.class, () -> new CoreseIRI("   "));
+
+        assertThrows(IncorrectFormatException.class, () -> new CoreseIRI("\u00A0"));
+
+        assertThrows(IncorrectFormatException.class, () -> new CoreseIRI(""));
+
+        assertThrows(IncorrectFormatException.class, () -> new CoreseIRI("test string"));
+
     }
 
 }