cluConstData 2.1.2

Compile-time macros for building persistent data structures in no_std and const environments. Supports buffer composition, and numeric formatting.
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

#[cfg(any(test, feature = "const_buf"))]
mod test_const_buf {
	use cluConstData::buf::ConstStrBuf;
	use cluConstData::buf::size::ConstByteBufSize;

	#[test]
	fn concat_writer_nums() {
		let mut u_writer = ConstStrBuf::<{ <usize as ConstByteBufSize>::MAX_DECIMAL_LEN }>::new();
		let u_sizeof = size_of::<usize>();

		if size_of::<u128>() <= u_sizeof {
			// machine u64 mode
			u_writer.push_usize(u128::MAX as _);
			assert!(core::str::from_utf8(u_writer.as_bytes()).is_ok());
			assert_eq!(u_writer.as_str(), "340282366920938463463374607431768211455");

			if size_of::<u128>() == u_sizeof {
				assert_eq!(u_writer.available(), 0);
			}
			u_writer.clear();
		}
		if size_of::<u64>() <= u_sizeof {
			// machine u64 mode
			u_writer.push_usize(u64::MAX as _);
			assert!(core::str::from_utf8(u_writer.as_bytes()).is_ok());
			assert_eq!(u_writer.as_str(), "18446744073709551615");
			if size_of::<u64>() == u_sizeof {
				assert_eq!(u_writer.available(), 0);
			}
			u_writer.clear();
		}
		if size_of::<u32>() <= u_sizeof {
			// machine u32 mode
			u_writer.push_usize(u32::MAX as _);
			assert!(core::str::from_utf8(u_writer.as_bytes()).is_ok());
			assert_eq!(u_writer.as_str(), "4294967295");
			if size_of::<u32>() == u_sizeof {
				assert_eq!(u_writer.available(), 0);
			}
			u_writer.clear();
		}
		if size_of::<u16>() <= u_sizeof {
			// machine u16 mode
			u_writer.push_usize(u16::MAX as _);
			assert!(core::str::from_utf8(u_writer.as_bytes()).is_ok());
			assert_eq!(u_writer.as_str(), "65535");
			if size_of::<u16>() == u_sizeof {
				assert_eq!(u_writer.available(), 0);
			}
			u_writer.clear();
		}
		if size_of::<u8>() <= u_sizeof {
			// machine u16 mode
			u_writer.push_usize(u8::MAX as _);
			assert!(core::str::from_utf8(u_writer.as_bytes()).is_ok());
			assert_eq!(u_writer.as_str(), "255");
			if size_of::<u8>() == u_sizeof {
				assert_eq!(u_writer.available(), 0);
			}
			u_writer.clear();
		}

		// zero
		u_writer.push_usize(0 as _);
		assert_eq!(u_writer.as_str(), "0");
		u_writer.clear();
		assert_eq!(u_writer.as_str(), "");
	}

	#[test]
	fn concat_writer_str() {
		let a_size = 1024;
		let b_size = 1025;

		// format_test
		//
		// format!(
		//	Error using `transmute`, size of type A={} is not equal to size of type B={}.
		// )
		const S0: &str = "Error using `transmute`, size of type A=";
		const S1: &str = " is not equal to size of type B=";

		let mut concat = ConstStrBuf::<
			{
				S0.len()
					+ <usize as ConstByteBufSize>::MAX_DECIMAL_LEN
					+ S1.len() + <usize as ConstByteBufSize>::MAX_DECIMAL_LEN
					+ <char as ConstByteBufSize>::MAX_DECIMAL_LEN
			},
		>::new();
		concat.push_str(S0);
		assert_eq!(concat.get(0), Some(&b'E'));
		assert_eq!(concat.get(1), Some(&b'r'));
		assert_eq!(concat.get(345), None);
		concat.push_usize(a_size);
		concat.push_str(S1);
		concat.push_usize(b_size);
		assert_eq!(
			concat.as_str(),
			"Error using `transmute`, size of type A=1024 is not equal to size of type B=1025",
		);
		concat.push_char('.');

		assert!(core::str::from_utf8(concat.as_bytes()).is_ok());
		assert_eq!(
			concat.as_str(),
			"Error using `transmute`, size of type A=1024 is not equal to size of type B=1025.",
		);
	}

	#[test]
	fn push_usize_isize() {
		{
			// usize MAX
			let mut w = ConstStrBuf::<{ <usize as ConstByteBufSize>::MAX_DECIMAL_LEN }>::new();
			w.push_usize(usize::MAX);

			assert_eq!(w, usize::MAX.to_string().as_bytes());
		}
		{
			// isize MAX
			let mut w = ConstStrBuf::<{ <isize as ConstByteBufSize>::MAX_DECIMAL_LEN }>::new();
			w.push_isize(isize::MAX);

			assert_eq!(w, isize::MAX.to_string().as_bytes());
		}
		{
			// isize MIN
			let mut w = ConstStrBuf::<{ <isize as ConstByteBufSize>::MAX_DECIMAL_LEN }>::new();
			w.push_isize(isize::MIN);

			assert_eq!(w, isize::MIN.to_string().as_bytes());
		}
	}
}