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