1 #include <gtest/gtest.h>
2
3 #include <cpuinfo.h>
4 #include <cpuinfo-mock.h>
5
6
TEST(PROCESSORS,count)7 TEST(PROCESSORS, count) {
8 ASSERT_EQ(2, cpuinfo_processors_count);
9 }
10
TEST(PROCESSORS,non_null)11 TEST(PROCESSORS, non_null) {
12 ASSERT_TRUE(cpuinfo_get_processors());
13 }
14
TEST(PROCESSORS,vendor)15 TEST(PROCESSORS, vendor) {
16 for (uint32_t i = 0; i < cpuinfo_processors_count; i++) {
17 ASSERT_EQ(cpuinfo_vendor_cavium, cpuinfo_get_processors()[i].vendor);
18 }
19 }
20
TEST(PROCESSORS,uarch)21 TEST(PROCESSORS, uarch) {
22 for (uint32_t i = 0; i < cpuinfo_processors_count; i++) {
23 ASSERT_EQ(cpuinfo_uarch_thunderx, cpuinfo_get_processors()[i].uarch);
24 }
25 }
26
TEST(ISA,thumb)27 TEST(ISA, thumb) {
28 ASSERT_TRUE(cpuinfo_isa.thumb);
29 }
30
TEST(ISA,thumb2)31 TEST(ISA, thumb2) {
32 ASSERT_TRUE(cpuinfo_isa.thumb2);
33 }
34
TEST(ISA,thumbee)35 TEST(ISA, thumbee) {
36 ASSERT_FALSE(cpuinfo_isa.thumbee);
37 }
38
TEST(ISA,jazelle)39 TEST(ISA, jazelle) {
40 ASSERT_FALSE(cpuinfo_isa.jazelle);
41 }
42
TEST(ISA,armv5e)43 TEST(ISA, armv5e) {
44 ASSERT_TRUE(cpuinfo_isa.armv5e);
45 }
46
TEST(ISA,armv6)47 TEST(ISA, armv6) {
48 ASSERT_TRUE(cpuinfo_isa.armv6);
49 }
50
TEST(ISA,armv6k)51 TEST(ISA, armv6k) {
52 ASSERT_TRUE(cpuinfo_isa.armv6k);
53 }
54
TEST(ISA,armv7)55 TEST(ISA, armv7) {
56 ASSERT_TRUE(cpuinfo_isa.armv7);
57 }
58
TEST(ISA,armv7mp)59 TEST(ISA, armv7mp) {
60 ASSERT_TRUE(cpuinfo_isa.armv7mp);
61 }
62
TEST(ISA,idiv)63 TEST(ISA, idiv) {
64 ASSERT_TRUE(cpuinfo_isa.idiv);
65 }
66
TEST(ISA,vfpv2)67 TEST(ISA, vfpv2) {
68 ASSERT_FALSE(cpuinfo_isa.vfpv2);
69 }
70
TEST(ISA,vfpv3)71 TEST(ISA, vfpv3) {
72 ASSERT_TRUE(cpuinfo_isa.vfpv3);
73 }
74
TEST(ISA,d32)75 TEST(ISA, d32) {
76 ASSERT_TRUE(cpuinfo_isa.d32);
77 }
78
TEST(ISA,fp16)79 TEST(ISA, fp16) {
80 ASSERT_TRUE(cpuinfo_isa.fp16);
81 }
82
TEST(ISA,fma)83 TEST(ISA, fma) {
84 ASSERT_TRUE(cpuinfo_isa.fma);
85 }
86
TEST(ISA,wmmx)87 TEST(ISA, wmmx) {
88 ASSERT_FALSE(cpuinfo_isa.wmmx);
89 }
90
TEST(ISA,wmmx2)91 TEST(ISA, wmmx2) {
92 ASSERT_FALSE(cpuinfo_isa.wmmx2);
93 }
94
TEST(ISA,neon)95 TEST(ISA, neon) {
96 ASSERT_TRUE(cpuinfo_isa.neon);
97 }
98
TEST(ISA,aes)99 TEST(ISA, aes) {
100 ASSERT_TRUE(cpuinfo_isa.aes);
101 }
102
TEST(ISA,sha1)103 TEST(ISA, sha1) {
104 ASSERT_TRUE(cpuinfo_isa.sha1);
105 }
106
TEST(ISA,sha2)107 TEST(ISA, sha2) {
108 ASSERT_TRUE(cpuinfo_isa.sha2);
109 }
110
TEST(ISA,pmull)111 TEST(ISA, pmull) {
112 ASSERT_TRUE(cpuinfo_isa.pmull);
113 }
114
TEST(ISA,crc32)115 TEST(ISA, crc32) {
116 ASSERT_TRUE(cpuinfo_isa.crc32);
117 }
118
119 #if CPUINFO_ARCH_ARM64
TEST(ISA,atomics)120 TEST(ISA, atomics) {
121 ASSERT_TRUE(cpuinfo_isa.atomics);
122 }
123
TEST(ISA,rdm)124 TEST(ISA, rdm) {
125 ASSERT_FALSE(cpuinfo_isa.rdm);
126 }
127
TEST(ISA,fp16arith)128 TEST(ISA, fp16arith) {
129 ASSERT_FALSE(cpuinfo_isa.fp16arith);
130 }
131
TEST(ISA,jscvt)132 TEST(ISA, jscvt) {
133 ASSERT_FALSE(cpuinfo_isa.jscvt);
134 }
135
TEST(ISA,fcma)136 TEST(ISA, fcma) {
137 ASSERT_FALSE(cpuinfo_isa.fcma);
138 }
139 #endif /* CPUINFO_ARCH_ARM64 */
140
TEST(L1I,count)141 TEST(L1I, count) {
142 ASSERT_EQ(2, cpuinfo_get_l1i_caches_count());
143 }
144
TEST(L1I,non_null)145 TEST(L1I, non_null) {
146 ASSERT_TRUE(cpuinfo_get_l1i_caches());
147 }
148
TEST(L1I,size)149 TEST(L1I, size) {
150 for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
151 ASSERT_EQ(78 * 1024, cpuinfo_get_l1i_cache(i)->size);
152 }
153 }
154
TEST(L1I,associativity)155 TEST(L1I, associativity) {
156 for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
157 ASSERT_EQ(4, cpuinfo_get_l1i_cache(i)->associativity);
158 }
159 }
160
TEST(L1I,sets)161 TEST(L1I, sets) {
162 for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
163 ASSERT_EQ(312, cpuinfo_get_l1i_cache(i)->sets);
164 }
165 }
166
TEST(L1I,partitions)167 TEST(L1I, partitions) {
168 for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
169 ASSERT_EQ(1, cpuinfo_get_l1i_cache(i)->partitions);
170 }
171 }
172
TEST(L1I,line_size)173 TEST(L1I, line_size) {
174 for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
175 ASSERT_EQ(64, cpuinfo_get_l1i_cache(i)->line_size);
176 }
177 }
178
TEST(L1I,flags)179 TEST(L1I, flags) {
180 for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
181 ASSERT_EQ(0, cpuinfo_get_l1i_cache(i)->flags);
182 }
183 }
184
TEST(L1I,processors)185 TEST(L1I, processors) {
186 for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
187 ASSERT_EQ(i, cpuinfo_get_l1i_cache(i)->processor_start);
188 ASSERT_EQ(1, cpuinfo_get_l1i_cache(i)->processor_count);
189 }
190 }
191
TEST(L1D,count)192 TEST(L1D, count) {
193 ASSERT_EQ(2, cpuinfo_get_l1d_caches_count());
194 }
195
TEST(L1D,non_null)196 TEST(L1D, non_null) {
197 ASSERT_TRUE(cpuinfo_get_l1d_caches());
198 }
199
TEST(L1D,size)200 TEST(L1D, size) {
201 for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
202 ASSERT_EQ(32 * 1024, cpuinfo_get_l1d_cache(i)->size);
203 }
204 }
205
TEST(L1D,associativity)206 TEST(L1D, associativity) {
207 for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
208 ASSERT_EQ(4, cpuinfo_get_l1d_cache(i)->associativity);
209 }
210 }
211
TEST(L1D,sets)212 TEST(L1D, sets) {
213 for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
214 ASSERT_EQ(128, cpuinfo_get_l1d_cache(i)->sets);
215 }
216 }
217
TEST(L1D,partitions)218 TEST(L1D, partitions) {
219 for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
220 ASSERT_EQ(1, cpuinfo_get_l1d_cache(i)->partitions);
221 }
222 }
223
TEST(L1D,line_size)224 TEST(L1D, line_size) {
225 for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
226 ASSERT_EQ(64, cpuinfo_get_l1d_cache(i)->line_size);
227 }
228 }
229
TEST(L1D,flags)230 TEST(L1D, flags) {
231 for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
232 ASSERT_EQ(0, cpuinfo_get_l1d_cache(i)->flags);
233 }
234 }
235
TEST(L1D,processors)236 TEST(L1D, processors) {
237 for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
238 ASSERT_EQ(i, cpuinfo_get_l1d_cache(i)->processor_start);
239 ASSERT_EQ(1, cpuinfo_get_l1d_cache(i)->processor_count);
240 }
241 }
242
TEST(L2,count)243 TEST(L2, count) {
244 ASSERT_EQ(1, cpuinfo_get_l2_caches_count());
245 }
246
TEST(L2,non_null)247 TEST(L2, non_null) {
248 ASSERT_TRUE(cpuinfo_get_l2_caches());
249 }
250
TEST(L2,size)251 TEST(L2, size) {
252 for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
253 ASSERT_EQ(16 * 1024 * 1024, cpuinfo_get_l2_cache(i)->size);
254 }
255 }
256
TEST(L2,associativity)257 TEST(L2, associativity) {
258 for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
259 ASSERT_EQ(8, cpuinfo_get_l2_cache(i)->associativity);
260 }
261 }
262
TEST(L2,sets)263 TEST(L2, sets) {
264 for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
265 ASSERT_EQ(32768, cpuinfo_get_l2_cache(i)->sets);
266 }
267 }
268
TEST(L2,partitions)269 TEST(L2, partitions) {
270 for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
271 ASSERT_EQ(1, cpuinfo_get_l2_cache(i)->partitions);
272 }
273 }
274
TEST(L2,line_size)275 TEST(L2, line_size) {
276 for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
277 ASSERT_EQ(64, cpuinfo_get_l2_cache(i)->line_size);
278 }
279 }
280
TEST(L2,flags)281 TEST(L2, flags) {
282 for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
283 ASSERT_EQ(0, cpuinfo_get_l2_cache(i)->flags);
284 }
285 }
286
TEST(L2,processors)287 TEST(L2, processors) {
288 for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
289 ASSERT_EQ(0, cpuinfo_get_l2_cache(i)->processor_start);
290 ASSERT_EQ(2, cpuinfo_get_l2_cache(i)->processor_count);
291 }
292 }
293
TEST(L3,none)294 TEST(L3, none) {
295 ASSERT_EQ(0, cpuinfo_get_l3_caches_count());
296 ASSERT_FALSE(cpuinfo_get_l3_caches());
297 }
298
TEST(L4,none)299 TEST(L4, none) {
300 ASSERT_EQ(0, cpuinfo_get_l4_caches_count());
301 ASSERT_FALSE(cpuinfo_get_l4_caches());
302 }
303
304 #include <scaleway.h>
305
main(int argc,char * argv[])306 int main(int argc, char* argv[]) {
307 cpuinfo_mock_filesystem(filesystem);
308 cpuinfo_initialize();
309 ::testing::InitGoogleTest(&argc, argv);
310 return RUN_ALL_TESTS();
311 }