xref: /webrtc/stun/src/addr/addr_test.rs (revision 7ceeeeb0) 
1 use super::*;
2 use crate::error::*;
3 
4 #[test]
5 fn test_mapped_address() -> Result<()> {
6     let mut m = Message::new();
7     let addr = MappedAddress {
8         ip: "122.12.34.5".parse().unwrap(),
9         port: 5412,
10     };
11     assert_eq!(addr.to_string(), "122.12.34.5:5412", "bad string {}", addr);
12 
13     //"add_to"
14     {
15         addr.add_to(&mut m)?;
16 
17         //"GetFrom"
18         {
19             let mut got = MappedAddress::default();
20             got.get_from(&mut m)?;
21             assert_eq!(got.ip, addr.ip, "got bad IP: {}", got.ip);
22 
23             //"Not found"
24             {
25                 let message = Message::new();
26                 let result = got.get_from(&message);
27                 if let Err(err) = result {
28                     assert_eq!(
29                         Error::ErrAttributeNotFound,
30                         err,
31                         "should be not found: {}",
32                         err
33                     );
34                 } else {
35                     assert!(false, "expected error, but got ok");
36                 }
37             }
38             //"Bad family"
39             {
40                 let (mut v, _) = m.attributes.get(ATTR_MAPPED_ADDRESS);
41                 v.value[0] = 32;
42                 got.get_from(&m)?
43             }
44             //"Bad length"
45             {
46                 let mut message = Message::new();
47                 message.add(ATTR_MAPPED_ADDRESS, &[1, 2, 3]);
48                 let result = got.get_from(&message);
49                 if let Err(err) = result {
50                     assert_eq!(
51                         Error::ErrUnexpectedEof,
52                         err,
53                         "<{}> should be <{}>",
54                         err,
55                         Error::ErrUnexpectedEof
56                     );
57                 } else {
58                     assert!(false, "expected error, but got ok");
59                 }
60             }
61         }
62     }
63 
64     Ok(())
65 }
66 
67 #[test]
68 fn test_mapped_address_v6() -> Result<()> {
69     let mut m = Message::new();
70     let addr = MappedAddress {
71         ip: "::".parse().unwrap(),
72         port: 5412,
73     };
74 
75     //"add_to"
76     {
77         addr.add_to(&mut m)?;
78 
79         //"GetFrom"
80         {
81             let mut got = MappedAddress::default();
82             got.get_from(&m)?;
83             assert_eq!(got.ip, addr.ip, "got bad IP: {}", got.ip);
84 
85             //"Not found"
86             {
87                 let message = Message::new();
88                 let result = got.get_from(&message);
89                 if let Err(err) = result {
90                     assert_eq!(
91                         Error::ErrAttributeNotFound,
92                         err,
93                         "<{}> should be <{}>",
94                         err,
95                         Error::ErrAttributeNotFound,
96                     );
97                 } else {
98                     assert!(false, "expected error, but got ok");
99                 }
100             }
101         }
102     }
103     Ok(())
104 }
105 
106 #[test]
107 fn test_alternate_server() -> Result<()> {
108     let mut m = Message::new();
109     let addr = MappedAddress {
110         ip: "122.12.34.5".parse().unwrap(),
111         port: 5412,
112     };
113 
114     //"add_to"
115     {
116         addr.add_to(&mut m)?;
117 
118         //"GetFrom"
119         {
120             let mut got = AlternateServer::default();
121             got.get_from(&m)?;
122             assert_eq!(got.ip, addr.ip, "got bad IP: {}", got.ip);
123 
124             //"Not found"
125             {
126                 let message = Message::new();
127                 let result = got.get_from(&message);
128                 if let Err(err) = result {
129                     assert_eq!(
130                         Error::ErrAttributeNotFound,
131                         err,
132                         "<{}> should be <{}>",
133                         err,
134                         Error::ErrAttributeNotFound,
135                     );
136                 } else {
137                     assert!(false, "expected error, but got ok");
138                 }
139             }
140         }
141     }
142 
143     Ok(())
144 }
145 
146 #[test]
147 fn test_other_address() -> Result<()> {
148     let mut m = Message::new();
149     let addr = OtherAddress {
150         ip: "122.12.34.5".parse().unwrap(),
151         port: 5412,
152     };
153 
154     //"add_to"
155     {
156         addr.add_to(&mut m)?;
157 
158         //"GetFrom"
159         {
160             let mut got = OtherAddress::default();
161             got.get_from(&m)?;
162             assert_eq!(got.ip, addr.ip, "got bad IP: {}", got.ip);
163 
164             //"Not found"
165             {
166                 let message = Message::new();
167                 let result = got.get_from(&message);
168                 if let Err(err) = result {
169                     assert_eq!(
170                         Error::ErrAttributeNotFound,
171                         err,
172                         "<{}> should be <{}>",
173                         err,
174                         Error::ErrAttributeNotFound,
175                     );
176                 } else {
177                     assert!(false, "expected error, but got ok");
178                 }
179             }
180         }
181     }
182 
183     Ok(())
184 }
185