update tot tests.

Author: ddooley

lib/Validator.js

@@ -291,20 +291,18 @@ class Validator {
       // Message needs
       for (const value of splitValues) {
         let parse_error = false;
+        let parsed_ok = false;
         if (slotType) {
           // Doesn't pertain to slots which are ONLY enumerations.
           const parsed = this.#parser.parse(value, slotType.uri);
 
-          // Issue: parse can fail on decimal but menu has "Missing"
           if (parsed === undefined) {
-            parse_error = `Value does not match format for ${slotType.uri}`;
-
-            //if (!(anyOfValidators.length || allOfValidators.length || exactlyOneOfValidators.length || noneOfValidators.length)) {
-            //  return parse_error;
-            //}
+            // Basic type check failed - return immediately with a clear type error.
+            // any_of/all_of/etc sub-validators can't meaningfully evaluate a
+            // value that already fails the declared top-level range type.
+            return `Value does not match format for ${slotType.uri}`;
           }
-          // All these cases have encountered an item which matches basic data
-          // datatype and so sudden death is ok.
+          // Value parsed successfully as the declared type.
           else {
             if (slotMinimumValue !== undefined && parsed < slotMinimumValue) {
               return 'Value is less than minimum value';
@@ -330,17 +328,19 @@ class Validator {
               return 'Value does not match pattern';
             }
 
-            // Here slotType value tested and is ok!
-            continue;
+            // Basic type constraints passed. Fall through to any_of/all_of/etc
+            // checks below, which may impose additional structural constraints.
+            parsed_ok = true;
           }
 
-          // Here value didn't parse to slotType
+          // Here value didn't parse to slotType (already returned above).
         } else {
           // No basic slot type here so only enumeration handling.
         }
 
-        // Single range for slot given so no need to evaluate all_of, any_of etc.
-        if (slotEnum && !slotPermissibleValues.includes(value)) {
+        // Enum check only for values that did not pass a basic type check.
+        // (A typed value that passes its type check is not subject to enum restriction.)
+        if (!parsed_ok && slotEnum && !slotPermissibleValues.includes(value)) {
           return 'Value is not allowed';
         }
 
@@ -384,15 +384,20 @@ class Validator {
           }
         }
 
+        // Typed value passed all basic and structural constraint checks.
+        if (parsed_ok) {
+          continue;
+        }
+
         if (
           anyOfValidators.length ||
           allOfValidators.length ||
           exactlyOneOfValidators.length ||
           noneOfValidators.length
         ) {
-          // We passed validation here which means a parse error can be overriden
+          // Passed validation via constraint validators; any parse error overridden.
         } else if (parse_error.length) {
-          //There were no other ranges besides basic slotType so
+          // No constraint validators present and basic type check failed.
           return parse_error;
         }
       }