fastxml 0.8.1

A fast, memory-efficient XML library with XPath and XSD validation support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

//! Basic schema construction tests.

use fastxml::schema::{CompiledSchema, ComplexType, ContentModel, ElementDef};

#[test]
fn test_compiled_schema() {
    let mut schema = CompiledSchema::new();

    // Add an element
    let elem = ElementDef::new("Building")
        .with_type("BuildingType")
        .optional();
    schema.elements.insert("Building".to_string(), elem);

    // Verify lookup
    let found = schema.get_element("Building");
    assert!(found.is_some());
    assert_eq!(found.unwrap().name, "Building");
    assert_eq!(found.unwrap().min_occurs, 0);
}

#[test]
fn test_element_def() {
    let elem = ElementDef::new("TestElement")
        .with_type("xs:string")
        .with_occurs(0, None)
        .optional()
        .unbounded();

    assert_eq!(elem.name, "TestElement");
    assert_eq!(elem.type_ref, Some("xs:string".to_string()));
    assert_eq!(elem.min_occurs, 0);
    assert_eq!(elem.max_occurs, None); // unbounded
}

#[test]
fn test_complex_type() {
    let child1 = ElementDef::new("child1").with_type("xs:string");
    let child2 = ElementDef::new("child2").with_type("xs:integer");

    let complex = ComplexType::sequence("MyType", vec![child1, child2]);

    assert_eq!(complex.name, "MyType");
    if let ContentModel::Sequence(elements) = &complex.content {
        assert_eq!(elements.len(), 2);
        assert_eq!(elements[0].name, "child1");
        assert_eq!(elements[1].name, "child2");
    } else {
        panic!("expected sequence content");
    }
}

#[test]
fn test_schema_with_namespace() {
    let schema = CompiledSchema::with_namespace("http://example.com/ns");
    assert_eq!(
        schema.target_namespace,
        Some("http://example.com/ns".to_string())
    );
}