webrtc-sdp 0.3.13

webrtc-sdp parses strings in the format of the Session Description Protocol according to RFC4566. It specifically supports the subset of features required to support WebRTC according to the JSEP draft.
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

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

use super::*;
use address::Address;
use std::str::FromStr;
#[test]
fn test_sdp_parser_internal_error_unknown_address_type() {
    let error = SdpParserInternalError::UnknownAddressType("foo".to_string());
    assert_eq!(
        format!("{error}"),
        format!("{}: {}", INTERNAL_ERROR_MESSAGE_UNKNOWN_ADDRESS_TYPE, "foo")
    );
    assert!(error.source().is_none());
}
#[test]
fn test_sdp_parser_internal_error_address_type_mismatch() {
    let error = SdpParserInternalError::AddressTypeMismatch {
        found: AddressType::IpV4,
        expected: AddressType::IpV6,
    };
    assert_eq!(
        format!("{error}"),
        format!(
            "{}: {}, {}",
            INTERNAL_ERROR_MESSAGE_ADDRESS_TYPE_MISMATCH,
            AddressType::IpV4,
            AddressType::IpV6
        )
    );
    assert!(error.source().is_none());
}

#[test]
fn test_sdp_parser_internal_error_generic() {
    let generic = SdpParserInternalError::Generic("generic message".to_string());
    assert_eq!(format!("{generic}"), "Parsing error: generic message");
    assert!(generic.source().is_none());
}

#[test]
fn test_sdp_parser_internal_error_unsupported() {
    let unsupported =
        SdpParserInternalError::Unsupported("unsupported internal message".to_string());
    assert_eq!(
        format!("{unsupported}"),
        "Unsupported parsing error: unsupported internal message"
    );
    assert!(unsupported.source().is_none());
}

#[test]
fn test_sdp_parser_internal_error_integer() {
    let v = "12a";
    let integer = v.parse::<u64>();
    assert!(integer.is_err());
    let int_err = SdpParserInternalError::Integer(integer.err().unwrap());
    assert_eq!(
        format!("{int_err}"),
        "Integer parsing error: invalid digit found in string"
    );
    assert!(int_err.source().is_some());
}

#[test]
fn test_sdp_parser_internal_error_float() {
    let v = "12.2a";
    let float = v.parse::<f32>();
    assert!(float.is_err());
    let int_err = SdpParserInternalError::Float(float.err().unwrap());
    assert_eq!(
        format!("{int_err}"),
        "Float parsing error: invalid float literal"
    );
    assert!(int_err.source().is_some());
}

#[test]
fn test_sdp_parser_internal_error_address() {
    let v = "127.0.0.500";
    let addr_err = Address::from_str(v).err().unwrap();
    assert_eq!(
        format!("{addr_err}"),
        "Domain name parsing error: invalid IPv4 address"
    );
    assert!(addr_err.source().is_some());
}

#[test]
fn test_sdp_parser_error_line() {
    let line1 = SdpParserError::Line {
        error: SdpParserInternalError::Generic("test message".to_string()),
        line: "test line".to_string(),
        line_number: 13,
    };
    assert_eq!(
        format!("{line1}"),
        "Line error: Parsing error: test message in line(13): test line"
    );
    assert!(line1.source().is_some());
}

#[test]
fn test_sdp_parser_error_unsupported() {
    let unsupported1 = SdpParserError::Unsupported {
        error: SdpParserInternalError::Generic("unsupported value".to_string()),
        line: "unsupported line".to_string(),
        line_number: 21,
    };
    assert_eq!(
        format!("{unsupported1}"),
        "Unsupported: Parsing error: unsupported value in line(21): unsupported line"
    );
    assert!(unsupported1.source().is_some());
}

#[test]
fn test_sdp_parser_error_sequence() {
    let sequence1 = SdpParserError::Sequence {
        message: "sequence message".to_string(),
        line_number: 42,
    };
    assert_eq!(
        format!("{sequence1}"),
        "Sequence error in line(42): sequence message"
    );
    assert!(sequence1.source().is_none());
}