irtt-client 0.1.1

IRTT-compatible Rust client library
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

use super::*;

#[test]
fn strict_negotiation_accepts_identical_params() {
    let config = ClientConfig::default();
    let params = params_from_config(&config).unwrap();
    assert!(validate_negotiated_params(&params, &params, NegotiationPolicy::Strict).is_ok());
}

#[test]
fn strict_negotiation_rejects_changed_params() {
    let config = ClientConfig::default();
    let requested = params_from_config(&config).unwrap();
    let mut returned = requested.clone();
    returned.dscp = 1;
    assert!(matches!(
        validate_negotiated_params(&requested, &returned, NegotiationPolicy::Strict),
        Err(ClientError::NegotiationRejected { .. })
    ));
}

#[test]
fn loose_negotiation_accepts_server_restricted_params() {
    let config = ClientConfig::default();
    let requested = params_from_config(&config).unwrap();
    let mut returned = requested.clone();
    returned.duration_ns /= 2;
    returned.length = 0;
    assert!(validate_negotiated_params(&requested, &returned, NegotiationPolicy::Loose).is_ok());
}

#[test]
fn loose_negotiation_rejects_non_positive_returned_interval() {
    let config = ClientConfig::default();
    let requested = params_from_config(&config).unwrap();

    for interval_ns in [0, -1] {
        let mut returned = requested.clone();
        returned.interval_ns = interval_ns;
        assert!(matches!(
            validate_negotiated_params(&requested, &returned, NegotiationPolicy::Loose),
            Err(ClientError::NegotiationRejected { reason })
                if reason == "interval must be positive"
        ));
    }
}

#[test]
fn loose_negotiation_accepts_documented_duration_combinations() {
    let finite_config = ClientConfig::default();
    let requested_finite = params_from_config(&finite_config).unwrap();

    let returned_same_finite = requested_finite.clone();
    assert!(validate_negotiated_params(
        &requested_finite,
        &returned_same_finite,
        NegotiationPolicy::Loose
    )
    .is_ok());

    let mut returned_shorter_finite = requested_finite.clone();
    returned_shorter_finite.duration_ns /= 2;
    assert!(validate_negotiated_params(
        &requested_finite,
        &returned_shorter_finite,
        NegotiationPolicy::Loose
    )
    .is_ok());

    let continuous_config = ClientConfig {
        duration: None,
        ..ClientConfig::default()
    };
    let requested_continuous = params_from_config(&continuous_config).unwrap();

    let returned_continuous = requested_continuous.clone();
    assert!(validate_negotiated_params(
        &requested_continuous,
        &returned_continuous,
        NegotiationPolicy::Loose
    )
    .is_ok());

    let mut returned_finite = requested_continuous.clone();
    returned_finite.duration_ns = 1_000_000_000;
    assert!(validate_negotiated_params(
        &requested_continuous,
        &returned_finite,
        NegotiationPolicy::Loose
    )
    .is_ok());
}

#[test]
fn loose_negotiation_rejects_finite_request_returned_continuous() {
    let config = ClientConfig::default();
    let requested = params_from_config(&config).unwrap();
    let mut returned = requested.clone();
    returned.duration_ns = 0;

    assert!(matches!(
        validate_negotiated_params(&requested, &returned, NegotiationPolicy::Loose),
        Err(ClientError::NegotiationRejected { reason })
            if reason == "server returned continuous duration for finite request"
    ));
}

#[test]
fn loose_negotiation_rejects_negative_returned_length() {
    let config = ClientConfig::default();
    let requested = params_from_config(&config).unwrap();
    let mut returned = requested.clone();
    returned.length = -1;
    assert!(matches!(
        validate_negotiated_params(&requested, &returned, NegotiationPolicy::Loose),
        Err(ClientError::NegotiationRejected { reason }) if reason == "length must be non-negative"
    ));
}

#[test]
fn strict_negotiation_rejects_negative_returned_length() {
    let config = ClientConfig::default();
    let requested = params_from_config(&config).unwrap();
    let mut returned = requested.clone();
    returned.length = -1;
    assert!(matches!(
        validate_negotiated_params(&requested, &returned, NegotiationPolicy::Strict),
        Err(ClientError::NegotiationRejected { reason }) if reason == "length must be non-negative"
    ));
}

#[test]
fn loose_negotiation_rejects_runtime_invalid_returned_dscp() {
    let config = ClientConfig::default();
    let requested = params_from_config(&config).unwrap();

    for dscp in [-1, 64] {
        let mut returned = requested.clone();
        returned.dscp = dscp;
        assert!(matches!(
            validate_negotiated_params(&requested, &returned, NegotiationPolicy::Loose),
            Err(ClientError::NegotiationRejected { reason })
                if reason == "dscp must be in range 0..=63"
        ));
    }
}