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
17 use crate::zram::MockSysfsZramApi;
18 use crate::zram::ZRAM_API_MTX;
19
20 #[test]
test_load_total_zram_size()21 fn test_load_total_zram_size() {
22 let _m = ZRAM_API_MTX.lock();
23 let mock = MockSysfsZramApi::read_disksize_context();
24 let contents = "12345\n";
25 mock.expect().returning(|| Ok(contents.to_string()));
26
27 assert_eq!(load_total_zram_size::<MockSysfsZramApi>().unwrap(), 12345);
28 }
29
30 #[test]
test_load_total_zram_size_invalid_value()31 fn test_load_total_zram_size_invalid_value() {
32 let _m = ZRAM_API_MTX.lock();
33 let mock = MockSysfsZramApi::read_disksize_context();
34 let contents = "a";
35 mock.expect().returning(|| Ok(contents.to_string()));
36
37 assert!(load_total_zram_size::<MockSysfsZramApi>().is_err());
38 }
39
40 #[test]
test_load_total_zram_size_fail_read()41 fn test_load_total_zram_size_fail_read() {
42 let _m = ZRAM_API_MTX.lock();
43 let mock = MockSysfsZramApi::read_disksize_context();
44 mock.expect().returning(|| Err(std::io::Error::other("error")));
45
46 assert!(load_total_zram_size::<MockSysfsZramApi>().is_err());
47 }
48
49 #[test]
test_zram_mm_stat()50 fn test_zram_mm_stat() {
51 let _m = ZRAM_API_MTX.lock();
52 let mock = MockSysfsZramApi::read_mm_stat_context();
53 let contents = " 1 2 3 4 5 6 7 8 9";
54 mock.expect().returning(|| Ok(contents.to_string()));
55
56 assert_eq!(
57 ZramMmStat::load::<MockSysfsZramApi>().unwrap(),
58 ZramMmStat {
59 orig_data_size: 1,
60 compr_data_size: 2,
61 mem_used_total: 3,
62 mem_limit: 4,
63 mem_used_max: 5,
64 same_pages: 6,
65 pages_compacted: 7,
66 huge_pages: Some(8),
67 huge_pages_since: Some(9),
68 }
69 );
70 }
71
72 #[test]
test_zram_mm_stat_skip_huge_pages_since()73 fn test_zram_mm_stat_skip_huge_pages_since() {
74 let _m = ZRAM_API_MTX.lock();
75 let mock = MockSysfsZramApi::read_mm_stat_context();
76 let contents = " 1 2 3 4 5 6 7 8";
77 mock.expect().returning(|| Ok(contents.to_string()));
78
79 assert_eq!(
80 ZramMmStat::load::<MockSysfsZramApi>().unwrap(),
81 ZramMmStat {
82 orig_data_size: 1,
83 compr_data_size: 2,
84 mem_used_total: 3,
85 mem_limit: 4,
86 mem_used_max: 5,
87 same_pages: 6,
88 pages_compacted: 7,
89 huge_pages: Some(8),
90 huge_pages_since: None,
91 }
92 );
93 }
94
95 #[test]
test_zram_mm_stat_skip_huge_pages()96 fn test_zram_mm_stat_skip_huge_pages() {
97 let _m = ZRAM_API_MTX.lock();
98 let mock = MockSysfsZramApi::read_mm_stat_context();
99 let contents = " 1 2 3 4 5 6 7";
100 mock.expect().returning(|| Ok(contents.to_string()));
101
102 assert_eq!(
103 ZramMmStat::load::<MockSysfsZramApi>().unwrap(),
104 ZramMmStat {
105 orig_data_size: 1,
106 compr_data_size: 2,
107 mem_used_total: 3,
108 mem_limit: 4,
109 mem_used_max: 5,
110 same_pages: 6,
111 pages_compacted: 7,
112 huge_pages: None,
113 huge_pages_since: None,
114 }
115 );
116 }
117
118 #[test]
test_zram_mm_stat_negative_mem_used_max()119 fn test_zram_mm_stat_negative_mem_used_max() {
120 let _m = ZRAM_API_MTX.lock();
121 let mock = MockSysfsZramApi::read_mm_stat_context();
122 let contents = " 1 2 3 4 -5 6 7 8 9";
123 mock.expect().returning(|| Ok(contents.to_string()));
124
125 assert_eq!(
126 ZramMmStat::load::<MockSysfsZramApi>().unwrap(),
127 ZramMmStat {
128 orig_data_size: 1,
129 compr_data_size: 2,
130 mem_used_total: 3,
131 mem_limit: 4,
132 mem_used_max: -5,
133 same_pages: 6,
134 pages_compacted: 7,
135 huge_pages: Some(8),
136 huge_pages_since: Some(9),
137 }
138 );
139 }
140
141 #[test]
test_zram_mm_stat_fail_read()142 fn test_zram_mm_stat_fail_read() {
143 let _m = ZRAM_API_MTX.lock();
144 let mock = MockSysfsZramApi::read_mm_stat_context();
145 mock.expect().returning(|| Err(std::io::Error::other("error")));
146
147 assert!(ZramMmStat::load::<MockSysfsZramApi>().is_err());
148 }
149
150 #[test]
test_zram_mm_stat_less_values()151 fn test_zram_mm_stat_less_values() {
152 let _m = ZRAM_API_MTX.lock();
153 let mock = MockSysfsZramApi::read_mm_stat_context();
154 let contents = " 1 2 3 4 5 6";
155 mock.expect().returning(|| Ok(contents.to_string()));
156
157 assert!(ZramMmStat::load::<MockSysfsZramApi>().is_err());
158 }
159
160 #[test]
test_zram_mm_stat_invalid_value()161 fn test_zram_mm_stat_invalid_value() {
162 let _m = ZRAM_API_MTX.lock();
163 let mock = MockSysfsZramApi::read_mm_stat_context();
164 let contents = " 1 2 3 4 5 6 a";
165 mock.expect().returning(|| Ok(contents.to_string()));
166
167 assert!(ZramMmStat::load::<MockSysfsZramApi>().is_err());
168 }
169
170 #[test]
test_zram_bd_stat()171 fn test_zram_bd_stat() {
172 let _m = ZRAM_API_MTX.lock();
173 let mock = MockSysfsZramApi::read_bd_stat_context();
174 let contents = "1 2 3";
175 mock.expect().returning(|| Ok(contents.to_string()));
176
177 assert_eq!(
178 ZramBdStat::load::<MockSysfsZramApi>().unwrap(),
179 ZramBdStat { bd_count_pages: 1, bd_reads_pages: 2, bd_writes_pages: 3 }
180 );
181 }
182
183 #[test]
test_zram_bd_stat_fail_read()184 fn test_zram_bd_stat_fail_read() {
185 let _m = ZRAM_API_MTX.lock();
186 let mock = MockSysfsZramApi::read_bd_stat_context();
187 mock.expect().returning(|| Err(std::io::Error::other("error")));
188
189 assert!(ZramBdStat::load::<MockSysfsZramApi>().is_err());
190 }
191
192 #[test]
test_zram_bd_stat_less_values()193 fn test_zram_bd_stat_less_values() {
194 let _m = ZRAM_API_MTX.lock();
195 let mock = MockSysfsZramApi::read_bd_stat_context();
196 let contents = "1 2";
197 mock.expect().returning(|| Ok(contents.to_string()));
198
199 assert!(ZramBdStat::load::<MockSysfsZramApi>().is_err());
200 }
201
202 #[test]
test_zram_bd_stat_invalid_value()203 fn test_zram_bd_stat_invalid_value() {
204 let _m = ZRAM_API_MTX.lock();
205 let mock = MockSysfsZramApi::read_bd_stat_context();
206 let contents = "1 2 a";
207 mock.expect().returning(|| Ok(contents.to_string()));
208
209 assert!(ZramBdStat::load::<MockSysfsZramApi>().is_err());
210 }
211