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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

//! Tests for the XPath parser.

use super::ast::{Axis, ComparisonOp, Expr, NodeTest, Predicate};
use super::parse_xpath;

#[test]
fn test_simple_path() {
    let expr = parse_xpath("/root/child").unwrap();
    if let Expr::Path(path) = expr {
        assert!(path.absolute);
        assert_eq!(path.steps.len(), 2);
        assert_eq!(path.steps[0].node_test, NodeTest::Name("root".into()));
        assert_eq!(path.steps[1].node_test, NodeTest::Name("child".into()));
    } else {
        panic!("expected Path");
    }
}

#[test]
fn test_descendant() {
    let expr = parse_xpath("//element").unwrap();
    if let Expr::Path(path) = expr {
        assert!(path.absolute);
        // Should have descendant-or-self step + element step
        assert_eq!(path.steps.len(), 2);
        assert_eq!(path.steps[0].axis, Axis::DescendantOrSelf);
    } else {
        panic!("expected Path");
    }
}

#[test]
fn test_predicate_name() {
    let expr = parse_xpath("//*[name()='Building']").unwrap();
    if let Expr::Path(path) = expr {
        assert_eq!(path.steps.len(), 2);
        let step = &path.steps[1];
        assert_eq!(step.predicates.len(), 1);
        if let Predicate::Comparison { op, .. } = &step.predicates[0] {
            assert_eq!(*op, ComparisonOp::Equal);
        } else {
            panic!("expected comparison predicate");
        }
    } else {
        panic!("expected Path");
    }
}

#[test]
fn test_logical_or() {
    let expr = parse_xpath("//*[(name()='A' or name()='B')]").unwrap();
    if let Expr::Path(path) = expr {
        let step = &path.steps[1];
        assert!(!step.predicates.is_empty());
        assert!(matches!(&step.predicates[0], Predicate::Or(_, _)));
    } else {
        panic!("expected Path");
    }
}

#[test]
fn test_not_predicate() {
    let expr = parse_xpath("//*[not(name()='Window')]").unwrap();
    if let Expr::Path(path) = expr {
        let step = &path.steps[1];
        assert!(!step.predicates.is_empty());
        assert!(matches!(&step.predicates[0], Predicate::Not(_)));
    } else {
        panic!("expected Path");
    }
}

#[test]
fn test_namespaced_path() {
    let expr = parse_xpath("/gml:root/gml:child").unwrap();
    if let Expr::Path(path) = expr {
        assert_eq!(path.steps.len(), 2);
        assert_eq!(
            path.steps[0].node_test,
            NodeTest::QName {
                prefix: "gml".into(),
                local: "root".into(),
            }
        );
    } else {
        panic!("expected Path");
    }
}

#[test]
fn test_child_axis() {
    let expr = parse_xpath("./child::*").unwrap();
    if let Expr::Path(path) = expr {
        assert!(!path.absolute);
        assert_eq!(path.steps.len(), 2);
        assert_eq!(path.steps[1].axis, Axis::Child);
        assert_eq!(path.steps[1].node_test, NodeTest::Any);
    } else {
        panic!("expected Path");
    }
}

#[test]
fn test_text_node() {
    let expr = parse_xpath("/root/text()").unwrap();
    if let Expr::Path(path) = expr {
        assert_eq!(path.steps.len(), 2);
        assert_eq!(path.steps[1].node_test, NodeTest::Text);
    } else {
        panic!("expected Path");
    }
}