1 use super::utils::{test_get_default_device, Scope};
2 use super::*;
3
4 // get_device_uid
5 // ------------------------------------
6 #[test]
test_get_device_uid()7 fn test_get_device_uid() {
8 // Input device.
9 if let Some(input) = test_get_default_device(Scope::Input) {
10 let uid = get_device_uid(input, DeviceType::INPUT).unwrap();
11 let uid = uid.into_string();
12 assert!(!uid.is_empty());
13 }
14
15 // Output device.
16 if let Some(output) = test_get_default_device(Scope::Output) {
17 let uid = get_device_uid(output, DeviceType::OUTPUT).unwrap();
18 let uid = uid.into_string();
19 assert!(!uid.is_empty());
20 }
21 }
22
23 #[test]
24 #[should_panic]
test_get_device_uid_by_unknwon_device()25 fn test_get_device_uid_by_unknwon_device() {
26 // Unknown device.
27 assert!(get_device_uid(kAudioObjectUnknown, DeviceType::INPUT).is_err());
28 }
29
30 // get_device_model_uid
31 // ------------------------------------
32 // Some devices (e.g., AirPods) fail to get model uid.
33 #[test]
test_get_device_model_uid()34 fn test_get_device_model_uid() {
35 if let Some(device) = test_get_default_device(Scope::Input) {
36 match get_device_model_uid(device, DeviceType::INPUT) {
37 Ok(uid) => println!("input model uid: {}", uid.into_string()),
38 Err(e) => println!("No input model uid. Error: {}", e),
39 }
40 } else {
41 println!("No input device.");
42 }
43
44 if let Some(device) = test_get_default_device(Scope::Output) {
45 match get_device_model_uid(device, DeviceType::OUTPUT) {
46 Ok(uid) => println!("output model uid: {}", uid.into_string()),
47 Err(e) => println!("No output model uid. Error: {}", e),
48 }
49 } else {
50 println!("No output device.");
51 }
52 }
53
54 #[test]
55 #[should_panic]
test_get_device_model_uid_by_unknown_device()56 fn test_get_device_model_uid_by_unknown_device() {
57 assert!(get_device_model_uid(kAudioObjectUnknown, DeviceType::INPUT).is_err());
58 }
59
60 // get_device_transport_type
61 // ------------------------------------
62 #[test]
test_get_device_transport_type()63 fn test_get_device_transport_type() {
64 if let Some(device) = test_get_default_device(Scope::Input) {
65 match get_device_transport_type(device, DeviceType::INPUT) {
66 Ok(trans_type) => println!(
67 "input transport type: {:X}, {:?}",
68 trans_type,
69 convert_uint32_into_string(trans_type)
70 ),
71 Err(e) => println!("No input transport type. Error: {}", e),
72 }
73 } else {
74 println!("No input device.");
75 }
76
77 if let Some(device) = test_get_default_device(Scope::Output) {
78 match get_device_transport_type(device, DeviceType::OUTPUT) {
79 Ok(trans_type) => println!(
80 "output transport type: {:X}, {:?}",
81 trans_type,
82 convert_uint32_into_string(trans_type)
83 ),
84 Err(e) => println!("No output transport type. Error: {}", e),
85 }
86 } else {
87 println!("No output device.");
88 }
89 }
90
91 #[test]
92 #[should_panic]
test_get_device_transport_type_by_unknown_device()93 fn test_get_device_transport_type_by_unknown_device() {
94 assert!(get_device_transport_type(kAudioObjectUnknown, DeviceType::INPUT).is_err());
95 }
96
97 // get_device_source
98 // ------------------------------------
99 // Some USB headsets (e.g., Plantronic .Audio 628) fails to get data source.
100 #[test]
test_get_device_source()101 fn test_get_device_source() {
102 if let Some(device) = test_get_default_device(Scope::Input) {
103 match get_device_source(device, DeviceType::INPUT) {
104 Ok(source) => println!(
105 "input source: {:X}, {:?}",
106 source,
107 convert_uint32_into_string(source)
108 ),
109 Err(e) => println!("No input data source. Error: {}", e),
110 }
111 } else {
112 println!("No input device.");
113 }
114
115 if let Some(device) = test_get_default_device(Scope::Output) {
116 match get_device_source(device, DeviceType::OUTPUT) {
117 Ok(source) => println!(
118 "output source: {:X}, {:?}",
119 source,
120 convert_uint32_into_string(source)
121 ),
122 Err(e) => println!("No output data source. Error: {}", e),
123 }
124 } else {
125 println!("No output device.");
126 }
127 }
128
129 #[test]
130 #[should_panic]
test_get_device_source_by_unknown_device()131 fn test_get_device_source_by_unknown_device() {
132 assert!(get_device_source(kAudioObjectUnknown, DeviceType::INPUT).is_err());
133 }
134
135 // get_device_source_name
136 // ------------------------------------
137 #[test]
test_get_device_source_name()138 fn test_get_device_source_name() {
139 if let Some(device) = test_get_default_device(Scope::Input) {
140 match get_device_source_name(device, DeviceType::INPUT) {
141 Ok(name) => println!("input: {}", name.into_string()),
142 Err(e) => println!("No input data source name. Error: {}", e),
143 }
144 } else {
145 println!("No input device.");
146 }
147
148 if let Some(device) = test_get_default_device(Scope::Output) {
149 match get_device_source_name(device, DeviceType::OUTPUT) {
150 Ok(name) => println!("output: {}", name.into_string()),
151 Err(e) => println!("No output data source name. Error: {}", e),
152 }
153 } else {
154 println!("No output device.");
155 }
156 }
157
158 #[test]
159 #[should_panic]
test_get_device_source_name_by_unknown_device()160 fn test_get_device_source_name_by_unknown_device() {
161 assert!(get_device_source_name(kAudioObjectUnknown, DeviceType::INPUT).is_err());
162 }
163
164 // get_device_name
165 // ------------------------------------
166 #[test]
test_get_device_name()167 fn test_get_device_name() {
168 if let Some(device) = test_get_default_device(Scope::Input) {
169 let name = get_device_name(device, DeviceType::INPUT).unwrap();
170 println!("input device name: {}", name.into_string());
171 } else {
172 println!("No input device.");
173 }
174
175 if let Some(device) = test_get_default_device(Scope::Output) {
176 let name = get_device_name(device, DeviceType::OUTPUT).unwrap();
177 println!("output device name: {}", name.into_string());
178 } else {
179 println!("No output device.");
180 }
181 }
182
183 #[test]
184 #[should_panic]
test_get_device_name_by_unknown_device()185 fn test_get_device_name_by_unknown_device() {
186 assert!(get_device_name(kAudioObjectUnknown, DeviceType::INPUT).is_err());
187 }
188
189 // get_device_manufacturer
190 // ------------------------------------
191 #[test]
test_get_device_manufacturer()192 fn test_get_device_manufacturer() {
193 if let Some(device) = test_get_default_device(Scope::Input) {
194 // Some devices like AirPods cannot get the vendor info so we print the error directly.
195 // TODO: Replace `map` and `unwrap_or_else` by `map_or_else`
196 let name = get_device_manufacturer(device, DeviceType::INPUT)
197 .map(|name| name.into_string())
198 .unwrap_or_else(|e| format!("Error: {}", e));
199 println!("input device vendor: {}", name);
200 } else {
201 println!("No input device.");
202 }
203
204 if let Some(device) = test_get_default_device(Scope::Output) {
205 // Some devices like AirPods cannot get the vendor info so we print the error directly.
206 // TODO: Replace `map` and `unwrap_or_else` by `map_or_else`
207 let name = get_device_manufacturer(device, DeviceType::OUTPUT)
208 .map(|name| name.into_string())
209 .unwrap_or_else(|e| format!("Error: {}", e));
210 println!("output device vendor: {}", name);
211 } else {
212 println!("No output device.");
213 }
214 }
215
216 #[test]
217 #[should_panic]
test_get_device_manufacturer_by_unknown_device()218 fn test_get_device_manufacturer_by_unknown_device() {
219 assert!(get_device_manufacturer(kAudioObjectUnknown, DeviceType::INPUT).is_err());
220 }
221
222 // get_device_buffer_frame_size_range
223 // ------------------------------------
224 #[test]
test_get_device_buffer_frame_size_range()225 fn test_get_device_buffer_frame_size_range() {
226 if let Some(device) = test_get_default_device(Scope::Input) {
227 let range = get_device_buffer_frame_size_range(device, DeviceType::INPUT).unwrap();
228 println!(
229 "range of input buffer frame size: {}-{}",
230 range.mMinimum, range.mMaximum
231 );
232 } else {
233 println!("No input device.");
234 }
235
236 if let Some(device) = test_get_default_device(Scope::Output) {
237 let range = get_device_buffer_frame_size_range(device, DeviceType::OUTPUT).unwrap();
238 println!(
239 "range of output buffer frame size: {}-{}",
240 range.mMinimum, range.mMaximum
241 );
242 } else {
243 println!("No output device.");
244 }
245 }
246
247 #[test]
248 #[should_panic]
test_get_device_buffer_frame_size_range_by_unknown_device()249 fn test_get_device_buffer_frame_size_range_by_unknown_device() {
250 assert!(get_device_buffer_frame_size_range(kAudioObjectUnknown, DeviceType::INPUT).is_err());
251 }
252
253 // get_device_latency
254 // ------------------------------------
255 #[test]
test_get_device_latency()256 fn test_get_device_latency() {
257 if let Some(device) = test_get_default_device(Scope::Input) {
258 let latency = get_device_latency(device, DeviceType::INPUT).unwrap();
259 println!("latency of input device: {}", latency);
260 } else {
261 println!("No input device.");
262 }
263
264 if let Some(device) = test_get_default_device(Scope::Output) {
265 let latency = get_device_latency(device, DeviceType::OUTPUT).unwrap();
266 println!("latency of output device: {}", latency);
267 } else {
268 println!("No output device.");
269 }
270 }
271
272 #[test]
273 #[should_panic]
test_get_device_latency_by_unknown_device()274 fn test_get_device_latency_by_unknown_device() {
275 assert!(get_device_latency(kAudioObjectUnknown, DeviceType::INPUT).is_err());
276 }
277
278 // get_device_streams
279 // ------------------------------------
280 #[test]
test_get_device_streams()281 fn test_get_device_streams() {
282 if let Some(device) = test_get_default_device(Scope::Input) {
283 let streams = get_device_streams(device, DeviceType::INPUT).unwrap();
284 println!("streams on the input device: {:?}", streams);
285 } else {
286 println!("No input device.");
287 }
288
289 if let Some(device) = test_get_default_device(Scope::Output) {
290 let streams = get_device_streams(device, DeviceType::OUTPUT).unwrap();
291 println!("streams on the output device: {:?}", streams);
292 } else {
293 println!("No output device.");
294 }
295 }
296
297 #[test]
298 #[should_panic]
test_get_device_streams_by_unknown_device()299 fn test_get_device_streams_by_unknown_device() {
300 assert!(get_device_streams(kAudioObjectUnknown, DeviceType::INPUT).is_err());
301 }
302
303 // get_device_sample_rate
304 // ------------------------------------
305 #[test]
test_get_device_sample_rate()306 fn test_get_device_sample_rate() {
307 if let Some(device) = test_get_default_device(Scope::Input) {
308 let rate = get_device_sample_rate(device, DeviceType::INPUT).unwrap();
309 println!("input sample rate: {}", rate);
310 } else {
311 println!("No input device.");
312 }
313
314 if let Some(device) = test_get_default_device(Scope::Output) {
315 let rate = get_device_sample_rate(device, DeviceType::OUTPUT).unwrap();
316 println!("output sample rate: {}", rate);
317 } else {
318 println!("No output device.");
319 }
320 }
321
322 #[test]
323 #[should_panic]
test_get_device_sample_rate_by_unknown_device()324 fn test_get_device_sample_rate_by_unknown_device() {
325 assert!(get_device_sample_rate(kAudioObjectUnknown, DeviceType::INPUT).is_err());
326 }
327
328 // get_ranges_of_device_sample_rate
329 // ------------------------------------
330 #[test]
test_get_ranges_of_device_sample_rate()331 fn test_get_ranges_of_device_sample_rate() {
332 if let Some(device) = test_get_default_device(Scope::Input) {
333 let ranges = get_ranges_of_device_sample_rate(device, DeviceType::INPUT).unwrap();
334 println!("ranges of input sample rate: {:?}", ranges);
335 } else {
336 println!("No input device.");
337 }
338
339 if let Some(device) = test_get_default_device(Scope::Output) {
340 let ranges = get_ranges_of_device_sample_rate(device, DeviceType::OUTPUT).unwrap();
341 println!("ranges of output sample rate: {:?}", ranges);
342 } else {
343 println!("No output device.");
344 }
345 }
346
347 #[test]
348 #[should_panic]
test_get_ranges_of_device_sample_rate_by_unknown_device()349 fn test_get_ranges_of_device_sample_rate_by_unknown_device() {
350 assert!(get_ranges_of_device_sample_rate(kAudioObjectUnknown, DeviceType::INPUT).is_err());
351 }
352
353 // get_device_stream_format
354 // ------------------------------------
355 #[test]
test_get_device_stream_format()356 fn test_get_device_stream_format() {
357 if let Some(device) = test_get_default_device(Scope::Input) {
358 let format = get_device_stream_format(device, DeviceType::INPUT).unwrap();
359 println!("input stream format: {:?}", format);
360 } else {
361 println!("No input device.");
362 }
363
364 if let Some(device) = test_get_default_device(Scope::Output) {
365 let format = get_device_stream_format(device, DeviceType::OUTPUT).unwrap();
366 println!("output stream format: {:?}", format);
367 } else {
368 println!("No output device.");
369 }
370 }
371
372 #[test]
373 #[should_panic]
test_get_device_stream_format_by_unknown_device()374 fn test_get_device_stream_format_by_unknown_device() {
375 assert!(get_device_stream_format(kAudioObjectUnknown, DeviceType::INPUT).is_err());
376 }
377
378 // get_device_stream_configuration
379 // ------------------------------------
380 #[test]
test_get_device_stream_configuration()381 fn test_get_device_stream_configuration() {
382 if let Some(device) = test_get_default_device(Scope::Input) {
383 let buffers = get_device_stream_configuration(device, DeviceType::INPUT).unwrap();
384 println!("input stream config: {:?}", buffers);
385 } else {
386 println!("No input device.");
387 }
388
389 if let Some(device) = test_get_default_device(Scope::Output) {
390 let buffers = get_device_stream_configuration(device, DeviceType::OUTPUT).unwrap();
391 println!("output stream config: {:?}", buffers);
392 } else {
393 println!("No output device.");
394 }
395 }
396
397 #[test]
398 #[should_panic]
test_get_device_stream_configuration_by_unknown_device()399 fn test_get_device_stream_configuration_by_unknown_device() {
400 assert!(get_device_stream_configuration(kAudioObjectUnknown, DeviceType::INPUT).is_err());
401 }
402
403 // get_stream_latency
404 // ------------------------------------
405 #[test]
test_get_stream_latency()406 fn test_get_stream_latency() {
407 if let Some(device) = test_get_default_device(Scope::Input) {
408 let streams = get_device_streams(device, DeviceType::INPUT).unwrap();
409 for stream in streams {
410 let latency = get_stream_latency(stream, DeviceType::INPUT).unwrap();
411 println!("latency of the input stream {} is {}", stream, latency);
412 }
413 } else {
414 println!("No input device.");
415 }
416
417 if let Some(device) = test_get_default_device(Scope::Output) {
418 let streams = get_device_streams(device, DeviceType::OUTPUT).unwrap();
419 for stream in streams {
420 let latency = get_stream_latency(stream, DeviceType::OUTPUT).unwrap();
421 println!("latency of the output stream {} is {}", stream, latency);
422 }
423 } else {
424 println!("No output device.");
425 }
426 }
427
428 #[test]
429 #[should_panic]
test_get_stream_latency_by_unknown_device()430 fn test_get_stream_latency_by_unknown_device() {
431 assert!(get_stream_latency(kAudioObjectUnknown, DeviceType::INPUT).is_err());
432 }
433