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(4, cpuinfo_get_processors_count());
9 }
10
TEST(PROCESSORS,non_null)11 TEST(PROCESSORS, non_null) {
12 ASSERT_TRUE(cpuinfo_get_processors());
13 }
14
TEST(PROCESSORS,smt_id)15 TEST(PROCESSORS, smt_id) {
16 for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
17 ASSERT_EQ(0, cpuinfo_get_processor(i)->smt_id);
18 }
19 }
20
TEST(PROCESSORS,core)21 TEST(PROCESSORS, core) {
22 for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
23 ASSERT_EQ(cpuinfo_get_core(i), cpuinfo_get_processor(i)->core);
24 }
25 }
26
TEST(PROCESSORS,cluster)27 TEST(PROCESSORS, cluster) {
28 for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
29 ASSERT_EQ(cpuinfo_get_cluster(0), cpuinfo_get_processor(i)->cluster);
30 }
31 }
32
TEST(PROCESSORS,package)33 TEST(PROCESSORS, package) {
34 for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
35 ASSERT_EQ(cpuinfo_get_package(0), cpuinfo_get_processor(i)->package);
36 }
37 }
38
TEST(PROCESSORS,linux_id)39 TEST(PROCESSORS, linux_id) {
40 for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
41 ASSERT_EQ(i, cpuinfo_get_processor(i)->linux_id);
42 }
43 }
44
TEST(PROCESSORS,l1i)45 TEST(PROCESSORS, l1i) {
46 for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
47 ASSERT_EQ(cpuinfo_get_l1i_cache(i), cpuinfo_get_processor(i)->cache.l1i);
48 }
49 }
50
TEST(PROCESSORS,l1d)51 TEST(PROCESSORS, l1d) {
52 for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
53 ASSERT_EQ(cpuinfo_get_l1d_cache(i), cpuinfo_get_processor(i)->cache.l1d);
54 }
55 }
56
TEST(PROCESSORS,l2)57 TEST(PROCESSORS, l2) {
58 for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
59 ASSERT_EQ(cpuinfo_get_l2_cache(0), cpuinfo_get_processor(i)->cache.l2);
60 }
61 }
62
TEST(PROCESSORS,l3)63 TEST(PROCESSORS, l3) {
64 for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
65 ASSERT_FALSE(cpuinfo_get_processor(i)->cache.l3);
66 }
67 }
68
TEST(PROCESSORS,l4)69 TEST(PROCESSORS, l4) {
70 for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
71 ASSERT_FALSE(cpuinfo_get_processor(i)->cache.l4);
72 }
73 }
74
TEST(CORES,count)75 TEST(CORES, count) {
76 ASSERT_EQ(4, cpuinfo_get_cores_count());
77 }
78
TEST(CORES,non_null)79 TEST(CORES, non_null) {
80 ASSERT_TRUE(cpuinfo_get_cores());
81 }
82
TEST(CORES,processor_start)83 TEST(CORES, processor_start) {
84 for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
85 ASSERT_EQ(i, cpuinfo_get_core(i)->processor_start);
86 }
87 }
88
TEST(CORES,processor_count)89 TEST(CORES, processor_count) {
90 for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
91 ASSERT_EQ(1, cpuinfo_get_core(i)->processor_count);
92 }
93 }
94
TEST(CORES,core_id)95 TEST(CORES, core_id) {
96 for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
97 ASSERT_EQ(i, cpuinfo_get_core(i)->core_id);
98 }
99 }
100
TEST(CORES,cluster)101 TEST(CORES, cluster) {
102 for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
103 ASSERT_EQ(cpuinfo_get_cluster(0), cpuinfo_get_core(i)->cluster);
104 }
105 }
106
TEST(CORES,package)107 TEST(CORES, package) {
108 for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
109 ASSERT_EQ(cpuinfo_get_package(0), cpuinfo_get_core(i)->package);
110 }
111 }
112
TEST(CORES,vendor)113 TEST(CORES, vendor) {
114 for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
115 ASSERT_EQ(cpuinfo_vendor_arm, cpuinfo_get_core(i)->vendor);
116 }
117 }
118
TEST(CORES,uarch)119 TEST(CORES, uarch) {
120 for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
121 ASSERT_EQ(cpuinfo_uarch_cortex_a7, cpuinfo_get_core(i)->uarch);
122 }
123 }
124
TEST(CORES,midr)125 TEST(CORES, midr) {
126 for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
127 ASSERT_EQ(UINT32_C(0x410FC075), cpuinfo_get_core(i)->midr);
128 }
129 }
130
TEST(CORES,DISABLED_frequency)131 TEST(CORES, DISABLED_frequency) {
132 for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
133 ASSERT_EQ(UINT64_C(1344000000), cpuinfo_get_core(i)->frequency);
134 }
135 }
136
TEST(CLUSTERS,count)137 TEST(CLUSTERS, count) {
138 ASSERT_EQ(1, cpuinfo_get_clusters_count());
139 }
140
TEST(CLUSTERS,non_null)141 TEST(CLUSTERS, non_null) {
142 ASSERT_TRUE(cpuinfo_get_clusters());
143 }
144
TEST(CLUSTERS,processor_start)145 TEST(CLUSTERS, processor_start) {
146 for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
147 ASSERT_EQ(0, cpuinfo_get_cluster(i)->processor_start);
148 }
149 }
150
TEST(CLUSTERS,processor_count)151 TEST(CLUSTERS, processor_count) {
152 for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
153 ASSERT_EQ(4, cpuinfo_get_cluster(i)->processor_count);
154 }
155 }
156
TEST(CLUSTERS,core_start)157 TEST(CLUSTERS, core_start) {
158 for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
159 ASSERT_EQ(0, cpuinfo_get_cluster(i)->core_start);
160 }
161 }
162
TEST(CLUSTERS,core_count)163 TEST(CLUSTERS, core_count) {
164 for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
165 ASSERT_EQ(4, cpuinfo_get_cluster(i)->core_count);
166 }
167 }
168
TEST(CLUSTERS,cluster_id)169 TEST(CLUSTERS, cluster_id) {
170 for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
171 ASSERT_EQ(i, cpuinfo_get_cluster(i)->cluster_id);
172 }
173 }
174
TEST(CLUSTERS,package)175 TEST(CLUSTERS, package) {
176 for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
177 ASSERT_EQ(cpuinfo_get_package(0), cpuinfo_get_cluster(i)->package);
178 }
179 }
180
TEST(CLUSTERS,vendor)181 TEST(CLUSTERS, vendor) {
182 for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
183 ASSERT_EQ(cpuinfo_vendor_arm, cpuinfo_get_cluster(i)->vendor);
184 }
185 }
186
TEST(CLUSTERS,uarch)187 TEST(CLUSTERS, uarch) {
188 for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
189 ASSERT_EQ(cpuinfo_uarch_cortex_a7, cpuinfo_get_cluster(i)->uarch);
190 }
191 }
192
TEST(CLUSTERS,midr)193 TEST(CLUSTERS, midr) {
194 for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
195 ASSERT_EQ(UINT32_C(0x410FC075), cpuinfo_get_cluster(i)->midr);
196 }
197 }
198
TEST(CLUSTERS,DISABLED_frequency)199 TEST(CLUSTERS, DISABLED_frequency) {
200 for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
201 ASSERT_EQ(UINT64_C(1344000000), cpuinfo_get_cluster(i)->frequency);
202 }
203 }
204
TEST(PACKAGES,count)205 TEST(PACKAGES, count) {
206 ASSERT_EQ(1, cpuinfo_get_packages_count());
207 }
208
TEST(PACKAGES,name)209 TEST(PACKAGES, name) {
210 for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
211 ASSERT_EQ("Allwinner A33",
212 std::string(cpuinfo_get_package(i)->name,
213 strnlen(cpuinfo_get_package(i)->name, CPUINFO_PACKAGE_NAME_MAX)));
214 }
215 }
216
TEST(PACKAGES,processor_start)217 TEST(PACKAGES, processor_start) {
218 for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
219 ASSERT_EQ(0, cpuinfo_get_package(i)->processor_start);
220 }
221 }
222
TEST(PACKAGES,processor_count)223 TEST(PACKAGES, processor_count) {
224 for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
225 ASSERT_EQ(4, cpuinfo_get_package(i)->processor_count);
226 }
227 }
228
TEST(PACKAGES,core_start)229 TEST(PACKAGES, core_start) {
230 for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
231 ASSERT_EQ(0, cpuinfo_get_package(i)->core_start);
232 }
233 }
234
TEST(PACKAGES,core_count)235 TEST(PACKAGES, core_count) {
236 for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
237 ASSERT_EQ(4, cpuinfo_get_package(i)->core_count);
238 }
239 }
240
TEST(PACKAGES,cluster_start)241 TEST(PACKAGES, cluster_start) {
242 for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
243 ASSERT_EQ(0, cpuinfo_get_package(i)->cluster_start);
244 }
245 }
246
TEST(PACKAGES,cluster_count)247 TEST(PACKAGES, cluster_count) {
248 for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
249 ASSERT_EQ(1, cpuinfo_get_package(i)->cluster_count);
250 }
251 }
252
TEST(ISA,thumb)253 TEST(ISA, thumb) {
254 ASSERT_TRUE(cpuinfo_has_arm_thumb());
255 }
256
TEST(ISA,thumb2)257 TEST(ISA, thumb2) {
258 ASSERT_TRUE(cpuinfo_has_arm_thumb2());
259 }
260
TEST(ISA,armv5e)261 TEST(ISA, armv5e) {
262 ASSERT_TRUE(cpuinfo_has_arm_v5e());
263 }
264
TEST(ISA,armv6)265 TEST(ISA, armv6) {
266 ASSERT_TRUE(cpuinfo_has_arm_v6());
267 }
268
TEST(ISA,armv6k)269 TEST(ISA, armv6k) {
270 ASSERT_TRUE(cpuinfo_has_arm_v6k());
271 }
272
TEST(ISA,armv7)273 TEST(ISA, armv7) {
274 ASSERT_TRUE(cpuinfo_has_arm_v7());
275 }
276
TEST(ISA,armv7mp)277 TEST(ISA, armv7mp) {
278 ASSERT_TRUE(cpuinfo_has_arm_v7mp());
279 }
280
TEST(ISA,idiv)281 TEST(ISA, idiv) {
282 ASSERT_TRUE(cpuinfo_has_arm_idiv());
283 }
284
TEST(ISA,vfpv2)285 TEST(ISA, vfpv2) {
286 ASSERT_FALSE(cpuinfo_has_arm_vfpv2());
287 }
288
TEST(ISA,vfpv3)289 TEST(ISA, vfpv3) {
290 ASSERT_TRUE(cpuinfo_has_arm_vfpv3());
291 }
292
TEST(ISA,vfpv3_d32)293 TEST(ISA, vfpv3_d32) {
294 ASSERT_TRUE(cpuinfo_has_arm_vfpv3_d32());
295 }
296
TEST(ISA,vfpv3_fp16)297 TEST(ISA, vfpv3_fp16) {
298 ASSERT_TRUE(cpuinfo_has_arm_vfpv3_fp16());
299 }
300
TEST(ISA,vfpv3_fp16_d32)301 TEST(ISA, vfpv3_fp16_d32) {
302 ASSERT_TRUE(cpuinfo_has_arm_vfpv3_fp16_d32());
303 }
304
TEST(ISA,vfpv4)305 TEST(ISA, vfpv4) {
306 ASSERT_TRUE(cpuinfo_has_arm_vfpv4());
307 }
308
TEST(ISA,vfpv4_d32)309 TEST(ISA, vfpv4_d32) {
310 ASSERT_TRUE(cpuinfo_has_arm_vfpv4_d32());
311 }
312
TEST(ISA,wmmx)313 TEST(ISA, wmmx) {
314 ASSERT_FALSE(cpuinfo_has_arm_wmmx());
315 }
316
TEST(ISA,wmmx2)317 TEST(ISA, wmmx2) {
318 ASSERT_FALSE(cpuinfo_has_arm_wmmx2());
319 }
320
TEST(ISA,neon)321 TEST(ISA, neon) {
322 ASSERT_TRUE(cpuinfo_has_arm_neon());
323 }
324
TEST(ISA,neon_fp16)325 TEST(ISA, neon_fp16) {
326 ASSERT_TRUE(cpuinfo_has_arm_neon_fp16());
327 }
328
TEST(ISA,neon_fma)329 TEST(ISA, neon_fma) {
330 ASSERT_TRUE(cpuinfo_has_arm_neon_fma());
331 }
332
TEST(ISA,atomics)333 TEST(ISA, atomics) {
334 ASSERT_FALSE(cpuinfo_has_arm_atomics());
335 }
336
TEST(ISA,neon_rdm)337 TEST(ISA, neon_rdm) {
338 ASSERT_FALSE(cpuinfo_has_arm_neon_rdm());
339 }
340
TEST(ISA,fp16_arith)341 TEST(ISA, fp16_arith) {
342 ASSERT_FALSE(cpuinfo_has_arm_fp16_arith());
343 }
344
TEST(ISA,neon_fp16_arith)345 TEST(ISA, neon_fp16_arith) {
346 ASSERT_FALSE(cpuinfo_has_arm_neon_fp16_arith());
347 }
348
TEST(ISA,neon_dot)349 TEST(ISA, neon_dot) {
350 ASSERT_FALSE(cpuinfo_has_arm_neon_dot());
351 }
352
TEST(ISA,jscvt)353 TEST(ISA, jscvt) {
354 ASSERT_FALSE(cpuinfo_has_arm_jscvt());
355 }
356
TEST(ISA,fcma)357 TEST(ISA, fcma) {
358 ASSERT_FALSE(cpuinfo_has_arm_fcma());
359 }
360
TEST(ISA,aes)361 TEST(ISA, aes) {
362 ASSERT_FALSE(cpuinfo_has_arm_aes());
363 }
364
TEST(ISA,sha1)365 TEST(ISA, sha1) {
366 ASSERT_FALSE(cpuinfo_has_arm_sha1());
367 }
368
TEST(ISA,sha2)369 TEST(ISA, sha2) {
370 ASSERT_FALSE(cpuinfo_has_arm_sha2());
371 }
372
TEST(ISA,pmull)373 TEST(ISA, pmull) {
374 ASSERT_FALSE(cpuinfo_has_arm_pmull());
375 }
376
TEST(ISA,crc32)377 TEST(ISA, crc32) {
378 ASSERT_FALSE(cpuinfo_has_arm_crc32());
379 }
380
TEST(L1I,count)381 TEST(L1I, count) {
382 ASSERT_EQ(4, cpuinfo_get_l1i_caches_count());
383 }
384
TEST(L1I,non_null)385 TEST(L1I, non_null) {
386 ASSERT_TRUE(cpuinfo_get_l1i_caches());
387 }
388
TEST(L1I,size)389 TEST(L1I, size) {
390 for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
391 ASSERT_EQ(32 * 1024, cpuinfo_get_l1i_cache(i)->size);
392 }
393 }
394
TEST(L1I,associativity)395 TEST(L1I, associativity) {
396 for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
397 ASSERT_EQ(2, cpuinfo_get_l1i_cache(i)->associativity);
398 }
399 }
400
TEST(L1I,sets)401 TEST(L1I, sets) {
402 for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
403 ASSERT_EQ(cpuinfo_get_l1i_cache(i)->size,
404 cpuinfo_get_l1i_cache(i)->sets * cpuinfo_get_l1i_cache(i)->line_size * cpuinfo_get_l1i_cache(i)->partitions * cpuinfo_get_l1i_cache(i)->associativity);
405 }
406 }
407
TEST(L1I,partitions)408 TEST(L1I, partitions) {
409 for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
410 ASSERT_EQ(1, cpuinfo_get_l1i_cache(i)->partitions);
411 }
412 }
413
TEST(L1I,line_size)414 TEST(L1I, line_size) {
415 for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
416 ASSERT_EQ(32, cpuinfo_get_l1i_cache(i)->line_size);
417 }
418 }
419
TEST(L1I,flags)420 TEST(L1I, flags) {
421 for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
422 ASSERT_EQ(0, cpuinfo_get_l1i_cache(i)->flags);
423 }
424 }
425
TEST(L1I,processors)426 TEST(L1I, processors) {
427 for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
428 ASSERT_EQ(i, cpuinfo_get_l1i_cache(i)->processor_start);
429 ASSERT_EQ(1, cpuinfo_get_l1i_cache(i)->processor_count);
430 }
431 }
432
TEST(L1D,count)433 TEST(L1D, count) {
434 ASSERT_EQ(4, cpuinfo_get_l1d_caches_count());
435 }
436
TEST(L1D,non_null)437 TEST(L1D, non_null) {
438 ASSERT_TRUE(cpuinfo_get_l1d_caches());
439 }
440
TEST(L1D,size)441 TEST(L1D, size) {
442 for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
443 ASSERT_EQ(32 * 1024, cpuinfo_get_l1d_cache(i)->size);
444 }
445 }
446
TEST(L1D,associativity)447 TEST(L1D, associativity) {
448 for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
449 ASSERT_EQ(4, cpuinfo_get_l1d_cache(i)->associativity);
450 }
451 }
452
TEST(L1D,sets)453 TEST(L1D, sets) {
454 for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
455 ASSERT_EQ(cpuinfo_get_l1d_cache(i)->size,
456 cpuinfo_get_l1d_cache(i)->sets * cpuinfo_get_l1d_cache(i)->line_size * cpuinfo_get_l1d_cache(i)->partitions * cpuinfo_get_l1d_cache(i)->associativity);
457 }
458 }
459
TEST(L1D,partitions)460 TEST(L1D, partitions) {
461 for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
462 ASSERT_EQ(1, cpuinfo_get_l1d_cache(i)->partitions);
463 }
464 }
465
TEST(L1D,line_size)466 TEST(L1D, line_size) {
467 for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
468 ASSERT_EQ(64, cpuinfo_get_l1d_cache(i)->line_size);
469 }
470 }
471
TEST(L1D,flags)472 TEST(L1D, flags) {
473 for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
474 ASSERT_EQ(0, cpuinfo_get_l1d_cache(i)->flags);
475 }
476 }
477
TEST(L1D,processors)478 TEST(L1D, processors) {
479 for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
480 ASSERT_EQ(i, cpuinfo_get_l1d_cache(i)->processor_start);
481 ASSERT_EQ(1, cpuinfo_get_l1d_cache(i)->processor_count);
482 }
483 }
484
TEST(L2,count)485 TEST(L2, count) {
486 ASSERT_EQ(1, cpuinfo_get_l2_caches_count());
487 }
488
TEST(L2,non_null)489 TEST(L2, non_null) {
490 ASSERT_TRUE(cpuinfo_get_l2_caches());
491 }
492
TEST(L2,size)493 TEST(L2, size) {
494 for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
495 ASSERT_EQ(512 * 1024, cpuinfo_get_l2_cache(i)->size);
496 }
497 }
498
TEST(L2,associativity)499 TEST(L2, associativity) {
500 for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
501 ASSERT_EQ(8, cpuinfo_get_l2_cache(i)->associativity);
502 }
503 }
504
TEST(L2,sets)505 TEST(L2, sets) {
506 for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
507 ASSERT_EQ(cpuinfo_get_l2_cache(i)->size,
508 cpuinfo_get_l2_cache(i)->sets * cpuinfo_get_l2_cache(i)->line_size * cpuinfo_get_l2_cache(i)->partitions * cpuinfo_get_l2_cache(i)->associativity);
509 }
510 }
511
TEST(L2,partitions)512 TEST(L2, partitions) {
513 for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
514 ASSERT_EQ(1, cpuinfo_get_l2_cache(i)->partitions);
515 }
516 }
517
TEST(L2,line_size)518 TEST(L2, line_size) {
519 for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
520 ASSERT_EQ(64, cpuinfo_get_l2_cache(i)->line_size);
521 }
522 }
523
TEST(L2,flags)524 TEST(L2, flags) {
525 for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
526 ASSERT_EQ(0, cpuinfo_get_l2_cache(i)->flags);
527 }
528 }
529
TEST(L2,processors)530 TEST(L2, processors) {
531 for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
532 ASSERT_EQ(0, cpuinfo_get_l2_cache(i)->processor_start);
533 ASSERT_EQ(4, cpuinfo_get_l2_cache(i)->processor_count);
534 }
535 }
536
TEST(L3,none)537 TEST(L3, none) {
538 ASSERT_EQ(0, cpuinfo_get_l3_caches_count());
539 ASSERT_FALSE(cpuinfo_get_l3_caches());
540 }
541
TEST(L4,none)542 TEST(L4, none) {
543 ASSERT_EQ(0, cpuinfo_get_l4_caches_count());
544 ASSERT_FALSE(cpuinfo_get_l4_caches());
545 }
546
547 #include <padcod-10.1.h>
548
main(int argc,char * argv[])549 int main(int argc, char* argv[]) {
550 #if CPUINFO_ARCH_ARM
551 cpuinfo_set_hwcap(UINT32_C(0x0007B8D7));
552 #endif
553 cpuinfo_mock_filesystem(filesystem);
554 #ifdef __ANDROID__
555 cpuinfo_mock_android_properties(properties);
556 #endif
557 cpuinfo_initialize();
558 ::testing::InitGoogleTest(&argc, argv);
559 return RUN_ALL_TESTS();
560 }
561