1 // Copyright 2024, The Android Open Source Project
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 use super::*;
16 use crate::zram::MockSysfsZramApi;
17 use crate::zram::ZRAM_API_MTX;
18
19 #[test]
test_load_total_zram_size()20 fn test_load_total_zram_size() {
21 let _m = ZRAM_API_MTX.lock();
22 let mock = MockSysfsZramApi::read_disksize_context();
23 let contents = "12345\n";
24 mock.expect().returning(|| Ok(contents.to_string()));
25
26 assert_eq!(load_total_zram_size::<MockSysfsZramApi>().unwrap(), 12345);
27 }
28
29 #[test]
test_load_total_zram_size_invalid_value()30 fn test_load_total_zram_size_invalid_value() {
31 let _m = ZRAM_API_MTX.lock();
32 let mock = MockSysfsZramApi::read_disksize_context();
33 let contents = "a";
34 mock.expect().returning(|| Ok(contents.to_string()));
35
36 assert!(load_total_zram_size::<MockSysfsZramApi>().is_err());
37 }
38
39 #[test]
test_load_total_zram_size_fail_read()40 fn test_load_total_zram_size_fail_read() {
41 let _m = ZRAM_API_MTX.lock();
42 let mock = MockSysfsZramApi::read_disksize_context();
43 mock.expect().returning(|| Err(std::io::Error::other("error")));
44
45 assert!(load_total_zram_size::<MockSysfsZramApi>().is_err());
46 }
47
48 #[test]
test_zram_mm_stat()49 fn test_zram_mm_stat() {
50 let _m = ZRAM_API_MTX.lock();
51 let mock = MockSysfsZramApi::read_mm_stat_context();
52 let contents = " 1 2 3 4 5 6 7 8 9";
53 mock.expect().returning(|| Ok(contents.to_string()));
54
55 assert_eq!(
56 ZramMmStat::load::<MockSysfsZramApi>().unwrap(),
57 ZramMmStat {
58 orig_data_size: 1,
59 compr_data_size: 2,
60 mem_used_total: 3,
61 mem_limit: 4,
62 mem_used_max: 5,
63 same_pages: 6,
64 pages_compacted: 7,
65 huge_pages: Some(8),
66 huge_pages_since: Some(9),
67 }
68 );
69 }
70
71 #[test]
test_zram_mm_stat_skip_huge_pages_since()72 fn test_zram_mm_stat_skip_huge_pages_since() {
73 let _m = ZRAM_API_MTX.lock();
74 let mock = MockSysfsZramApi::read_mm_stat_context();
75 let contents = " 1 2 3 4 5 6 7 8";
76 mock.expect().returning(|| Ok(contents.to_string()));
77
78 assert_eq!(
79 ZramMmStat::load::<MockSysfsZramApi>().unwrap(),
80 ZramMmStat {
81 orig_data_size: 1,
82 compr_data_size: 2,
83 mem_used_total: 3,
84 mem_limit: 4,
85 mem_used_max: 5,
86 same_pages: 6,
87 pages_compacted: 7,
88 huge_pages: Some(8),
89 huge_pages_since: None,
90 }
91 );
92 }
93
94 #[test]
test_zram_mm_stat_skip_huge_pages()95 fn test_zram_mm_stat_skip_huge_pages() {
96 let _m = ZRAM_API_MTX.lock();
97 let mock = MockSysfsZramApi::read_mm_stat_context();
98 let contents = " 1 2 3 4 5 6 7";
99 mock.expect().returning(|| Ok(contents.to_string()));
100
101 assert_eq!(
102 ZramMmStat::load::<MockSysfsZramApi>().unwrap(),
103 ZramMmStat {
104 orig_data_size: 1,
105 compr_data_size: 2,
106 mem_used_total: 3,
107 mem_limit: 4,
108 mem_used_max: 5,
109 same_pages: 6,
110 pages_compacted: 7,
111 huge_pages: None,
112 huge_pages_since: None,
113 }
114 );
115 }
116
117 #[test]
test_zram_mm_stat_negative_mem_used_max()118 fn test_zram_mm_stat_negative_mem_used_max() {
119 let _m = ZRAM_API_MTX.lock();
120 let mock = MockSysfsZramApi::read_mm_stat_context();
121 let contents = " 1 2 3 4 -5 6 7 8 9";
122 mock.expect().returning(|| Ok(contents.to_string()));
123
124 assert_eq!(
125 ZramMmStat::load::<MockSysfsZramApi>().unwrap(),
126 ZramMmStat {
127 orig_data_size: 1,
128 compr_data_size: 2,
129 mem_used_total: 3,
130 mem_limit: 4,
131 mem_used_max: -5,
132 same_pages: 6,
133 pages_compacted: 7,
134 huge_pages: Some(8),
135 huge_pages_since: Some(9),
136 }
137 );
138 }
139
140 #[test]
test_zram_mm_stat_fail_read()141 fn test_zram_mm_stat_fail_read() {
142 let _m = ZRAM_API_MTX.lock();
143 let mock = MockSysfsZramApi::read_mm_stat_context();
144 mock.expect().returning(|| Err(std::io::Error::other("error")));
145
146 assert!(ZramMmStat::load::<MockSysfsZramApi>().is_err());
147 }
148
149 #[test]
test_zram_mm_stat_less_values()150 fn test_zram_mm_stat_less_values() {
151 let _m = ZRAM_API_MTX.lock();
152 let mock = MockSysfsZramApi::read_mm_stat_context();
153 let contents = " 1 2 3 4 5 6";
154 mock.expect().returning(|| Ok(contents.to_string()));
155
156 assert!(ZramMmStat::load::<MockSysfsZramApi>().is_err());
157 }
158
159 #[test]
test_zram_mm_stat_invalid_value()160 fn test_zram_mm_stat_invalid_value() {
161 let _m = ZRAM_API_MTX.lock();
162 let mock = MockSysfsZramApi::read_mm_stat_context();
163 let contents = " 1 2 3 4 5 6 a";
164 mock.expect().returning(|| Ok(contents.to_string()));
165
166 assert!(ZramMmStat::load::<MockSysfsZramApi>().is_err());
167 }
168
169 #[test]
test_zram_bd_stat()170 fn test_zram_bd_stat() {
171 let _m = ZRAM_API_MTX.lock();
172 let mock = MockSysfsZramApi::read_bd_stat_context();
173 let contents = "1 2 3";
174 mock.expect().returning(|| Ok(contents.to_string()));
175
176 assert_eq!(
177 ZramBdStat::load::<MockSysfsZramApi>().unwrap(),
178 ZramBdStat { bd_count_pages: 1, bd_reads_pages: 2, bd_writes_pages: 3 }
179 );
180 }
181
182 #[test]
test_zram_bd_stat_fail_read()183 fn test_zram_bd_stat_fail_read() {
184 let _m = ZRAM_API_MTX.lock();
185 let mock = MockSysfsZramApi::read_bd_stat_context();
186 mock.expect().returning(|| Err(std::io::Error::other("error")));
187
188 assert!(ZramBdStat::load::<MockSysfsZramApi>().is_err());
189 }
190
191 #[test]
test_zram_bd_stat_less_values()192 fn test_zram_bd_stat_less_values() {
193 let _m = ZRAM_API_MTX.lock();
194 let mock = MockSysfsZramApi::read_bd_stat_context();
195 let contents = "1 2";
196 mock.expect().returning(|| Ok(contents.to_string()));
197
198 assert!(ZramBdStat::load::<MockSysfsZramApi>().is_err());
199 }
200
201 #[test]
test_zram_bd_stat_invalid_value()202 fn test_zram_bd_stat_invalid_value() {
203 let _m = ZRAM_API_MTX.lock();
204 let mock = MockSysfsZramApi::read_bd_stat_context();
205 let contents = "1 2 a";
206 mock.expect().returning(|| Ok(contents.to_string()));
207
208 assert!(ZramBdStat::load::<MockSysfsZramApi>().is_err());
209 }
210