Improved tests for tokens

lib/xml_schema_validator/src/token/text_content.rs

@@ -26,59 +26,104 @@ impl TextContent {
 }
 
 #[cfg(test)]
-mod text_content_tests {
+mod tests {
     use super::*;
-    use crate::schema;
-    use std::sync::Arc;
-
-    fn create_test_element() -> Arc<schema::XsElement> {
-        let element = schema::XsElement {
-            name: "reasoning".to_string(),
-            text: None,
-            xs_complex_type: schema::XsComplexType {
-                mixed: Some("true".to_string()),
-                text: None,
-                xs_attribute: None,
-                xs_sequence: Some(schema::XsSequence {
-                    text: None,
-                    xs_any: schema::XsAny {
-                        min_occurs: "0".to_string(),
-                        max_occurs: "unbounded".to_string(),
-                        process_contents: "skip".to_string(),
-                    },
-                }),
-            },
-        };
-        Arc::new(element)
-    }
 
     #[test]
-    fn test_text_content_normal_char() {
-        let element = create_test_element();
-        let token = TextContent::new(Arc::clone(&element));
+    fn test_valid_text_content() {
+        let values = [
+            "<reasoning>text",
+            "<reasoning>Hello world",
+            "<reasoning>Special chars: !@#$%^&*()",
+            "<reasoning>Numbers: 12345",
+            "<reasoning>Mixed content with spaces",
+            "<write_stdout>Output message",
+            "<single>ls -la /tmp",
+        ];
 
-        // Test with normal character
-        let next_tokens = token.append('a');
-        assert!(!next_tokens.is_empty(), "Should accept normal character");
-
-        match &next_tokens[0] {
-            Token::TextContent(_) => (),
-            _ => panic!("Expected TextContent, got {:?}", next_tokens[0]),
+        for value in values {
+            let mut validator = crate::tests::example_validator();
+            validator.append(value).expect(value);
+            assert!(!validator.current_tokens.is_empty(), "{value}");
+            assert!(
+                validator
+                    .current_tokens
+                    .iter()
+                    .any(|token| matches!(token, Token::TextContent(_))),
+                "{value}"
+            );
         }
     }
 
     #[test]
-    fn test_text_content_less_than() {
-        let element = create_test_element();
-        let token = TextContent::new(Arc::clone(&element));
+    fn test_whitespace_text_content() {
+        let values = [
+            "<reasoning> ",
+            "<reasoning>  ",
+            "<reasoning>\t",
+            "<reasoning>\n",
+            "<reasoning> \t\n ",
+            "<write_stdout> ",
+            "<single> ",
+        ];
 
-        // Test with < (start of tag)
-        let next_tokens = token.append('<');
-        assert!(!next_tokens.is_empty(), "Should accept '<'");
+        for value in values {
+            let mut validator = crate::tests::example_validator();
+            validator.append(value).expect(value);
+            assert!(!validator.current_tokens.is_empty(), "{value}");
+            assert!(
+                validator
+                    .current_tokens
+                    .iter()
+                    .any(|token| matches!(token, Token::TextContent(_))),
+                "{value}"
+            );
+        }
+    }
 
-        match &next_tokens[0] {
-            Token::ElementCloseStart(_) => (),
-            _ => panic!("Expected ElementCloseStart, got {:?}", next_tokens[0]),
+    #[test]
+    fn test_valid_element_close_start_after_text() {
+        let values = [
+            "<reasoning>text<",
+            "<reasoning>Hello world<",
+            "<write_stdout>message<",
+            "<single>command<",
+        ];
+
+        for value in values {
+            let mut validator = crate::tests::example_validator();
+            validator.append(value).expect(value);
+            assert!(!validator.current_tokens.is_empty(), "{value}");
+            assert!(
+                validator
+                    .current_tokens
+                    .iter()
+                    .any(|token| matches!(token, Token::ElementCloseStart(_))),
+                "{value}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_complete_element_with_text() {
+        let values = [
+            "<reasoning>text</reasoning>",
+            "<reasoning>Hello world</reasoning>",
+            "<write_stdout>message</write_stdout>",
+            "<single>command</single>",
+        ];
+
+        for value in values {
+            let mut validator = crate::tests::example_validator();
+            validator.append(value).expect(value);
+            assert!(!validator.current_tokens.is_empty(), "{value}");
+            assert!(
+                validator
+                    .current_tokens
+                    .iter()
+                    .any(|token| matches!(token, Token::EndOfFile(_))),
+                "{value}"
+            );
         }
     }
 }