serial2 0.2.38

Cross platform serial ports
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

use assert2::assert;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize)]
struct TeCharSize {
	cs: serial2::CharSize,
}

#[test]
fn test_serde_char_size() {
	assert!(let Ok(x) = serde_json::to_string(&serial2::CharSize::Bits5) && x == "5");
	assert!(let Ok(x) = serde_json::to_string(&serial2::CharSize::Bits6) && x == "6");
	assert!(let Ok(x) = serde_json::to_string(&serial2::CharSize::Bits7) && x == "7");
	assert!(let Ok(x) = serde_json::to_string(&serial2::CharSize::Bits8) && x == "8");

	assert!(let Ok(x) = toml::to_string(&TeCharSize { cs: serial2::CharSize::Bits5 }) && x == "cs = 5\n");
	assert!(let Ok(x) = toml::to_string(&TeCharSize { cs: serial2::CharSize::Bits6 }) && x == "cs = 6\n");
	assert!(let Ok(x) = toml::to_string(&TeCharSize { cs: serial2::CharSize::Bits7 }) && x == "cs = 7\n");
	assert!(let Ok(x) = toml::to_string(&TeCharSize { cs: serial2::CharSize::Bits8 }) && x == "cs = 8\n");

	assert!(let Ok(serial2::CharSize::Bits5) = serde_json::from_str::<serial2::CharSize>("5"));
	assert!(let Ok(serial2::CharSize::Bits5) = serde_json::from_str::<serial2::CharSize>("5"));
	assert!(let Ok(serial2::CharSize::Bits6) = serde_json::from_str::<serial2::CharSize>("6"));
	assert!(let Ok(serial2::CharSize::Bits7) = serde_json::from_str::<serial2::CharSize>("7"));
	assert!(let Ok(serial2::CharSize::Bits8) = serde_json::from_str::<serial2::CharSize>("8"));

	assert!(let Ok(x) = toml::from_str::<TeCharSize>("cs = 5\n") && x.cs == serial2::CharSize::Bits5);
	assert!(let Ok(x) = toml::from_str::<TeCharSize>("cs = 6") && x.cs == serial2::CharSize::Bits6);
	assert!(let Ok(x) = toml::from_str::<TeCharSize>("cs = 7") && x.cs == serial2::CharSize::Bits7);
	assert!(let Ok(x) = toml::from_str::<TeCharSize>("cs = 8") && x.cs == serial2::CharSize::Bits8);

	assert!(let Err(e) = serde_json::from_str::<serial2::CharSize>("4"));
	assert!(e.to_string() == "invalid value: integer `4`, expected the number 5, 6, 7 or 8 at line 1 column 1");

	assert!(let Err(e) = toml::from_str::<TeCharSize>("cs = 4"));
	assert!(e.to_string().ends_with("invalid value: integer `4`, expected the number 5, 6, 7 or 8\n"));

	assert!(let Err(e) = serde_json::from_str::<serial2::CharSize>("9"));
	assert!(e.to_string() == "invalid value: integer `9`, expected the number 5, 6, 7 or 8 at line 1 column 1");

	assert!(let Err(e) = serde_json::from_str::<serial2::CharSize>("\"5\""));
	assert!(e.to_string() == "invalid type: string \"5\", expected the number 5, 6, 7 or 8 at line 1 column 3");

	assert!(let Err(e) = toml::from_str::<TeCharSize>("cs = \"5\""));
	assert!(e.to_string().ends_with("invalid type: string \"5\", expected the number 5, 6, 7 or 8\n"));
}

#[derive(Deserialize, Serialize)]
struct TeStopBits {
	sb: serial2::StopBits,
}

#[test]
fn test_serde_stop_bits() {
	assert!(let Ok(x) = serde_json::to_string(&serial2::StopBits::One) && x == "1");
	assert!(let Ok(x) = serde_json::to_string(&serial2::StopBits::Two) && x == "2");

	assert!(let Ok(x) = toml::to_string(&TeStopBits { sb: serial2::StopBits::One }) && x == "sb = 1\n");
	assert!(let Ok(x) = toml::to_string(&TeStopBits { sb: serial2::StopBits::Two }) && x == "sb = 2\n");

	assert!(let Ok(serial2::StopBits::One) = serde_json::from_str::<serial2::StopBits>("1"));
	assert!(let Ok(serial2::StopBits::Two) = serde_json::from_str::<serial2::StopBits>("2"));

	assert!(let Ok(x) = toml::from_str::<TeStopBits>("sb = 1\n") && x.sb == serial2::StopBits::One);
	assert!(let Ok(x) = toml::from_str::<TeStopBits>("sb = 2") && x.sb == serial2::StopBits::Two);

	assert!(let Err(e) = serde_json::from_str::<serial2::StopBits>("0"));
	assert!(e.to_string() == "invalid value: integer `0`, expected the number 1 or 2 at line 1 column 1");

	assert!(let Err(e) = toml::from_str::<TeStopBits>("sb = 0"));
	assert!(e.to_string().ends_with("invalid value: integer `0`, expected the number 1 or 2\n"));

	assert!(let Err(e) = serde_json::from_str::<serial2::StopBits>("3"));
	assert!(e.to_string() == "invalid value: integer `3`, expected the number 1 or 2 at line 1 column 1");

	assert!(let Err(e) = serde_json::from_str::<serial2::StopBits>("\"1\""));
	assert!(e.to_string() == "invalid type: string \"1\", expected the number 1 or 2 at line 1 column 3");
}

#[test]
fn test_serde_parity() {
	assert!(let Ok(x) = serde_json::to_string(&serial2::Parity::None) && x == "\"none\"");
	assert!(let Ok(x) = serde_json::to_string(&serial2::Parity::Even) && x == "\"even\"");
	assert!(let Ok(x) = serde_json::to_string(&serial2::Parity::Odd) && x == "\"odd\"");

	assert!(let Ok(serial2::Parity::None) = serde_json::from_str::<serial2::Parity>("\"none\""));
	assert!(let Ok(serial2::Parity::Even) = serde_json::from_str::<serial2::Parity>("\"even\""));
	assert!(let Ok(serial2::Parity::Odd) = serde_json::from_str::<serial2::Parity>("\"odd\""));

	assert!(let Err(e) = serde_json::from_str::<serial2::Parity>("\"even-then-odd\""));
	assert!(e.to_string() == "invalid value: string \"even-then-odd\", expected the string \"none\", \"odd\" or \"even\" at line 1 column 15");
}

#[test]
fn test_serde_flow_control() {
	assert!(let Ok(x) = serde_json::to_string(&serial2::FlowControl::None) && x == "\"none\"");
	assert!(let Ok(x) = serde_json::to_string(&serial2::FlowControl::XonXoff) && x == "\"xon/xoff\"");
	assert!(let Ok(x) = serde_json::to_string(&serial2::FlowControl::RtsCts) && x == "\"rts/cts\"");

	assert!(let Ok(serial2::FlowControl::None) = serde_json::from_str::<serial2::FlowControl>("\"none\""));
	assert!(let Ok(serial2::FlowControl::XonXoff) = serde_json::from_str::<serial2::FlowControl>("\"xon/xoff\""));
	assert!(let Ok(serial2::FlowControl::RtsCts) = serde_json::from_str::<serial2::FlowControl>("\"rts/cts\""));

	assert!(let Err(e) = serde_json::from_str::<serial2::FlowControl>("\"plug-in/plug-out\""));
	assert!(e.to_string() == "invalid value: string \"plug-in/plug-out\", expected the string \"none\", \"xon/xoff\" or \"rts/cts\" at line 1 column 18");
}