ehttpd 0.14.0

A HTTP server nano-framework, which can be used to create custom small-scale HTTP server 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

use ehttpd::bytes::{Data, Parse};

#[test]
fn data_is_split_on_first_delimiter() {
    // Data containing multiple delimiters
    let mut data = Data::new_static(b"first::second::third");

    // Split the data on its first delimiter and ensure that the prefix is returned and the suffix is retained
    let prefix = data.split_off(b"::").expect("delimiter is missing");
    assert_eq!(prefix, b"first");
    assert_eq!(data, b"second::third");
}

#[test]
fn slice_is_split_on_first_delimiter() {
    // A byte slice containing multiple delimiters
    let mut data: &[u8] = b"first::second::third";

    // Split the slice on its first delimiter and ensure that the prefix is returned and the suffix is retained
    let prefix = Parse::split_off(&mut data, b"::").expect("delimiter is missing");
    assert_eq!(prefix, b"first");
    assert_eq!(data, b"second::third");
}

#[test]
fn missing_delimiter_leaves_data_unchanged() {
    // Data without the requested delimiter
    let mut data = Data::new_static(b"unchanged");

    // Attempt to split the data and ensure that no prefix is returned and the data is unchanged
    let prefix = data.split_off(b"::");
    assert!(prefix.is_none());
    assert_eq!(data, b"unchanged");
}

#[test]
fn ascii_whitespace_is_trimmed() {
    // Data and a slice surrounded by ASCII whitespace
    let data = concat! {
        " \t\r\n",
        "value \t\r\n",
    };
    let slice = concat! {
        " \t\r\n",
        "value \t\r\n",
    };

    // Trim both values
    let data = Data::new_static(data.as_bytes());
    let slice = slice.as_bytes();
    let trimmed_data = data.trim();
    let trimmed_slice = slice.trim();

    // Ensure that leading and trailing whitespace is removed
    assert_eq!(trimmed_data, b"value");
    assert_eq!(trimmed_slice, b"value");
}

#[test]
fn data_and_slice_are_parsed() {
    // Numeric data and a numeric slice
    let data = Data::new_static(b"1234");
    let slice: &[u8] = b"5678";

    // Parse both values and ensure that both values are parsed correctly
    let parsed_data: u16 = data.parse().expect("failed to parse data");
    let parsed_slice: u16 = slice.parse().expect("failed to parse slice");
    assert_eq!(parsed_data, 1234);
    assert_eq!(parsed_slice, 5678);
}

#[test]
fn invalid_number_is_rejected() {
    // Data that is not a number
    let data = Data::new_static(b"invalid");

    // Ensure that the data is rejected
    let parsed: Result<u16, _> = data.parse();
    let error = parsed.expect_err("invalid number was accepted");
    assert_eq!(error.error, "failed to parse data");
}

#[test]
fn invalid_utf8_is_rejected() {
    // Data that is not valid UTF-8
    let data = Data::new_static(b"\xFF");

    // Ensure that the data is rejected
    let parsed: Result<u16, _> = data.parse();
    let error = parsed.expect_err("invalid UTF-8 was accepted");
    assert_eq!(error.error, "Value is not valid UTF-8");
}