veilid-tools 0.5.4

A collection of baseline tools for Rust development use by Veilid and Veilid-enabled Rust applications
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use crate::*;
use std::net::IpAddr;
use std::str::FromStr;

macro_rules! assert_split_url {
    ($url:expr, $scheme:expr, $host:expr) => {
        assert_eq!(
            SplitUrl::from_str($url),
            Ok(SplitUrl::new($scheme, None, $host, None, None))
        );
    };
    ($url:expr, $scheme:expr, $host:expr, $port:expr) => {
        assert_eq!(
            SplitUrl::from_str($url),
            Ok(SplitUrl::new($scheme, None, $host, $port, None))
        );
    };
    ($url:expr, $scheme:expr, $host:expr, $port:expr, $path:expr) => {
        assert_eq!(
            SplitUrl::from_str($url),
            Ok(SplitUrl::new(
                $scheme,
                None,
                $host,
                $port,
                Some(SplitUrlPath::new(
                    $path,
                    Option::<String>::None,
                    Option::<String>::None
                ))
            ))
        );
    };
    ($url:expr, $scheme:expr, $host:expr, $port:expr, $path:expr, $frag:expr, $query:expr) => {
        assert_eq!(
            SplitUrl::from_str($url),
            Ok(SplitUrl::new(
                $scheme,
                None,
                $host,
                $port,
                Some(SplitUrlPath::new($path, $frag, $query))
            ))
        );
    };
}

macro_rules! assert_split_url_parse {
    ($url:expr) => {
        let url = $url;
        let su1 = SplitUrl::from_str(url).expect("should parse");
        assert_eq!(su1.to_string(), url);
    };
}

fn host<S: AsRef<str>>(s: S) -> SplitUrlHost {
    SplitUrlHost::Hostname(s.as_ref().to_owned())
}

fn ip<S: AsRef<str>>(s: S) -> SplitUrlHost {
    SplitUrlHost::IpAddr(IpAddr::from_str(s.as_ref()).unwrap())
}

pub fn test_split_url() {
    info!("testing split_url");

    assert_split_url!("http://foo", "http", host("foo"));
    assert_split_url!("http://foo:1234", "http", host("foo"), Some(1234));
    assert_split_url!("http://foo:1234/", "http", host("foo"), Some(1234), "");
    assert_split_url!(
        "http://foo:1234/asdf/qwer",
        "http",
        host("foo"),
        Some(1234),
        "asdf/qwer"
    );
    assert_split_url!("http://foo/", "http", host("foo"), None, "");
    assert_split_url!("http://11.2.3.144/", "http", ip("11.2.3.144"), None, "");
    assert_split_url!("http://[1111::2222]/", "http", ip("1111::2222"), None, "");
    assert_split_url!(
        "http://[1111::2222]:123/",
        "http",
        ip("1111::2222"),
        Some(123),
        ""
    );

    assert_split_url!(
        "http://foo/asdf/qwer",
        "http",
        host("foo"),
        None,
        "asdf/qwer"
    );
    assert_split_url!(
        "http://foo/asdf/qwer#3",
        "http",
        host("foo"),
        None,
        "asdf/qwer",
        Some("3"),
        Option::<String>::None
    );
    assert_split_url!(
        "http://foo/asdf/qwer?xxx",
        "http",
        host("foo"),
        None,
        "asdf/qwer",
        Option::<String>::None,
        Some("xxx")
    );
    assert_split_url!(
        "http://foo/asdf/qwer#yyy?xxx",
        "http",
        host("foo"),
        None,
        "asdf/qwer",
        Some("yyy"),
        Some("xxx")
    );
    assert_err!(SplitUrl::from_str("://asdf"));
    assert_err!(SplitUrl::from_str(""));
    assert_err!(SplitUrl::from_str("::"));
    assert_err!(SplitUrl::from_str("://:"));
    assert_err!(SplitUrl::from_str("a://:"));
    assert_err!(SplitUrl::from_str("a://:1243"));
    assert_err!(SplitUrl::from_str("a://:65536"));
    assert_err!(SplitUrl::from_str("a://:-16"));
    assert_err!(SplitUrl::from_str("a:///"));
    assert_err!(SplitUrl::from_str("a:///qwer:"));
    assert_err!(SplitUrl::from_str("a:///qwer://"));
    assert_err!(SplitUrl::from_str("a://qwer://"));
    assert_err!(SplitUrl::from_str("a://[1111::2222]:/"));
    assert_err!(SplitUrl::from_str("a://[1111::2222]:"));

    assert_split_url_parse!("sch://foo:bar@baz.com:1234/fnord#qux?zuz");
    assert_split_url_parse!("sch://foo:bar@baz.com:1234/fnord#qux");
    assert_split_url_parse!("sch://foo:bar@baz.com:1234/fnord?zuz");
    assert_split_url_parse!("sch://foo:bar@baz.com:1234/fnord/");
    assert_split_url_parse!("sch://foo:bar@baz.com:1234//");
    assert_split_url_parse!("sch://foo:bar@baz.com:1234");
    assert_split_url_parse!("sch://foo:bar@[1111::2222]:1234");
    assert_split_url_parse!("sch://foo:bar@[::]:1234");
    assert_split_url_parse!("sch://foo:bar@1.2.3.4:1234");
    assert_split_url_parse!("sch://@baz.com:1234");
    assert_split_url_parse!("sch://baz.com/asdf/asdf");
    assert_split_url_parse!("sch://baz.com/");
    assert_split_url_parse!("s://s");
}