iri-string 0.6.0

IRI as string types
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

//! Tests for percent encoding.

#[cfg(feature = "alloc")]
extern crate alloc;

#[macro_use]
mod utils;

#[cfg(feature = "alloc")]
use alloc::string::ToString;

use iri_string::percent_encode::{PercentEncodedForIri, PercentEncodedForUri};

#[test]
fn regname_uri() {
    let encoded = PercentEncodedForUri::from_reg_name("alpha.\u{03B1}.reg.name");
    let expected = "alpha.%CE%B1.reg.name";
    assert_eq_display!(encoded, expected);
    #[cfg(feature = "alloc")]
    assert_eq!(encoded.to_string(), expected);
}

#[test]
fn regname_iri() {
    let encoded = PercentEncodedForIri::from_reg_name("alpha.\u{03B1}.reg.name");
    let expected = "alpha.\u{03B1}.reg.name";
    assert_eq_display!(encoded, expected);
    #[cfg(feature = "alloc")]
    assert_eq!(encoded.to_string(), expected);
}

#[test]
fn path_segment_uri() {
    let encoded = PercentEncodedForUri::from_path_segment("\u{03B1}/<alpha>?#");
    let expected = "%CE%B1%2F%3Calpha%3E%3F%23";
    assert_eq_display!(encoded, expected);
    #[cfg(feature = "alloc")]
    assert_eq!(encoded.to_string(), expected);
}

#[test]
fn path_segment_iri() {
    let encoded = PercentEncodedForIri::from_path_segment("\u{03B1}/<alpha>?#");
    let expected = "\u{03B1}%2F%3Calpha%3E%3F%23";
    assert_eq_display!(encoded, expected);
    #[cfg(feature = "alloc")]
    assert_eq!(encoded.to_string(), expected);
}

#[test]
fn path_uri() {
    let encoded = PercentEncodedForUri::from_path("\u{03B1}/<alpha>?#");
    let expected = "%CE%B1/%3Calpha%3E%3F%23";
    assert_eq_display!(encoded, expected);
    #[cfg(feature = "alloc")]
    assert_eq!(encoded.to_string(), expected);
}

#[test]
fn path_iri() {
    let encoded = PercentEncodedForIri::from_path("\u{03B1}/<alpha>?#");
    let expected = "\u{03B1}/%3Calpha%3E%3F%23";
    assert_eq_display!(encoded, expected);
    #[cfg(feature = "alloc")]
    assert_eq!(encoded.to_string(), expected);
}

#[test]
fn query_uri() {
    let encoded = PercentEncodedForUri::from_query("\u{03B1}/<alpha>?#");
    let expected = "%CE%B1/%3Calpha%3E?%23";
    assert_eq_display!(encoded, expected);
    #[cfg(feature = "alloc")]
    assert_eq!(encoded.to_string(), expected);
}

#[test]
fn query_iri() {
    let encoded = PercentEncodedForIri::from_query("\u{03B1}/<alpha>?#");
    let expected = "\u{03B1}/%3Calpha%3E?%23";
    assert_eq_display!(encoded, expected);
    #[cfg(feature = "alloc")]
    assert_eq!(encoded.to_string(), expected);
}

#[test]
fn fragment_uri() {
    let encoded = PercentEncodedForUri::from_fragment("\u{03B1}/<alpha>?#");
    let expected = "%CE%B1/%3Calpha%3E?%23";
    assert_eq_display!(encoded, expected);
    #[cfg(feature = "alloc")]
    assert_eq!(encoded.to_string(), expected);
}

#[test]
fn fragment_iri() {
    let encoded = PercentEncodedForIri::from_fragment("\u{03B1}/<alpha>?#");
    let expected = "\u{03B1}/%3Calpha%3E?%23";
    assert_eq_display!(encoded, expected);
    #[cfg(feature = "alloc")]
    assert_eq!(encoded.to_string(), expected);
}