webrtc-constraints 0.1.0

A pure Rust implementation of WebRTC Media Constraints API
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

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

/// A capability specifying a range of supported values.
///
/// # W3C Spec Compliance
///
/// Corresponds to [`sequence<T>`][sequence] from the W3C ["WebIDL"][webidl_spec] spec:
///
/// | Rust                                      | W3C                   |
/// | ----------------------------------------- | --------------------- |
/// | `MediaTrackValueSequenceCapability<bool>` | `sequence<boolean>`   |
/// | `MediaTrackValueSequenceCapability<String>`  | `sequence<DOMString>` |
///
/// [sequence]: https://webidl.spec.whatwg.org/#idl-sequence
/// [webidl_spec]: https://webidl.spec.whatwg.org/
#[derive(Default, Debug, Clone, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", serde(transparent))]
pub struct MediaTrackValueSequenceCapability<T> {
    pub values: Vec<T>,
}

impl<T> From<T> for MediaTrackValueSequenceCapability<T> {
    fn from(value: T) -> Self {
        Self {
            values: vec![value],
        }
    }
}

impl<T> From<Vec<T>> for MediaTrackValueSequenceCapability<T> {
    fn from(values: Vec<T>) -> Self {
        Self { values }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    type Subject = MediaTrackValueSequenceCapability<String>;

    #[test]
    fn default() {
        let subject = Subject::default();

        let actual = subject.values;

        let expected: Vec<String> = vec![];

        assert_eq!(actual, expected);
    }

    mod from {
        use super::*;

        #[test]
        fn value() {
            let subject = Subject::from("foo".to_owned());

            let actual = subject.values;

            let expected: Vec<String> = vec!["foo".to_owned()];

            assert_eq!(actual, expected);
        }

        #[test]
        fn values() {
            let subject = Subject::from(vec!["foo".to_owned(), "bar".to_owned()]);

            let actual = subject.values;

            let expected: Vec<String> = vec!["foo".to_owned(), "bar".to_owned()];

            assert_eq!(actual, expected);
        }
    }
}

#[cfg(feature = "serde")]
#[cfg(test)]
mod serde_tests {
    use crate::macros::test_serde_symmetry;

    use super::*;

    type Subject = MediaTrackValueSequenceCapability<String>;

    #[test]
    fn customized() {
        let subject = Subject {
            values: vec!["foo".to_owned(), "bar".to_owned()],
        };
        let json = serde_json::json!(["foo", "bar"]);

        test_serde_symmetry!(subject: subject, json: json);
    }
}