Remove main() function from unit tests

2 files changed, 265 insertions, 12 deletions

diff --git a/test/get-current.cc b/test/get-current.cc
index c9bc1b9..4a80cab 100644
--- a/test/get-current.cc
+++ b/test/get-current.cc
@@ -4,10 +4,14 @@
 
 
 TEST(CURRENT_PROCESSOR, not_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
+
 	ASSERT_TRUE(cpuinfo_get_current_processor());
 }
 
 TEST(CURRENT_PROCESSOR, within_bounds) {
+	ASSERT_TRUE(cpuinfo_initialize());
+
 	const struct cpuinfo_processor* current_processor = cpuinfo_get_current_processor();
 	const struct cpuinfo_processor* processors_begin = cpuinfo_get_processors();
 	const struct cpuinfo_processor* processors_end = processors_begin + cpuinfo_get_processors_count();
@@ -16,19 +20,17 @@ TEST(CURRENT_PROCESSOR, within_bounds) {
 }
 
 TEST(CURRENT_CORE, not_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
+
 	ASSERT_TRUE(cpuinfo_get_current_core());
 }
 
 TEST(CURRENT_CORE, within_bounds) {
+	ASSERT_TRUE(cpuinfo_initialize());
+
 	const struct cpuinfo_core* current_core = cpuinfo_get_current_core();
 	const struct cpuinfo_core* cores_begin = cpuinfo_get_cores();
 	const struct cpuinfo_core* cores_end = cores_begin + cpuinfo_get_cores_count();
 	ASSERT_GE(current_core, cores_begin);
 	ASSERT_LT(current_core, cores_end);
 }
-
-int main(int argc, char* argv[]) {
-	cpuinfo_initialize();
-	::testing::InitGoogleTest(&argc, argv);
-	return RUN_ALL_TESTS();
-}
diff --git a/test/init.cc b/test/init.cc
index 0ab0127..941cb97 100644
--- a/test/init.cc
+++ b/test/init.cc
@@ -4,20 +4,27 @@
 
 
 TEST(PROCESSORS_COUNT, non_zero) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_NE(0, cpuinfo_get_processors_count());
+	cpuinfo_deinitialize();
 }
 
 TEST(PROCESSORS, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_TRUE(cpuinfo_get_processors());
+	cpuinfo_deinitialize();
 }
 
 TEST(PROCESSOR, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
 		EXPECT_TRUE(cpuinfo_get_processor(i));
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PROCESSOR, valid_smt_id) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
 		const cpuinfo_processor* processor = cpuinfo_get_processor(i);
 		ASSERT_TRUE(processor);
@@ -26,18 +33,22 @@ TEST(PROCESSOR, valid_smt_id) {
 
 		EXPECT_LT(processor->smt_id, core->processor_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PROCESSOR, valid_core) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
 		const cpuinfo_processor* processor = cpuinfo_get_processor(i);
 		ASSERT_TRUE(processor);
 
 		EXPECT_TRUE(processor->core);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PROCESSOR, consistent_core) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
 		const cpuinfo_processor* processor = cpuinfo_get_processor(i);
 		ASSERT_TRUE(processor);
@@ -47,18 +58,22 @@ TEST(PROCESSOR, consistent_core) {
 		EXPECT_GE(i, core->processor_start);
 		EXPECT_LT(i, core->processor_start + core->processor_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PROCESSOR, valid_cluster) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
 		const cpuinfo_processor* processor = cpuinfo_get_processor(i);
 		ASSERT_TRUE(processor);
 
 		EXPECT_TRUE(processor->cluster);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PROCESSOR, consistent_cluster) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
 		const cpuinfo_processor* processor = cpuinfo_get_processor(i);
 		ASSERT_TRUE(processor);
@@ -68,18 +83,22 @@ TEST(PROCESSOR, consistent_cluster) {
 		EXPECT_GE(i, cluster->processor_start);
 		EXPECT_LT(i, cluster->processor_start + cluster->processor_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PROCESSOR, valid_package) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
 		const cpuinfo_processor* processor = cpuinfo_get_processor(i);
 		ASSERT_TRUE(processor);
 
 		EXPECT_TRUE(processor->package);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PROCESSOR, consistent_package) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
 		const cpuinfo_processor* processor = cpuinfo_get_processor(i);
 		ASSERT_TRUE(processor);
@@ -89,9 +108,11 @@ TEST(PROCESSOR, consistent_package) {
 		EXPECT_GE(i, package->processor_start);
 		EXPECT_LT(i, package->processor_start + package->processor_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PROCESSOR, consistent_l1i) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
 		const cpuinfo_processor* processor = cpuinfo_get_processor(i);
 		ASSERT_TRUE(processor);
@@ -101,9 +122,11 @@ TEST(PROCESSOR, consistent_l1i) {
 			EXPECT_LT(i, l1i->processor_start + l1i->processor_count);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PROCESSOR, consistent_l1d) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
 		const cpuinfo_processor* processor = cpuinfo_get_processor(i);
 		ASSERT_TRUE(processor);
@@ -113,9 +136,11 @@ TEST(PROCESSOR, consistent_l1d) {
 			EXPECT_LT(i, l1d->processor_start + l1d->processor_count);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PROCESSOR, consistent_l2) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
 		const cpuinfo_processor* processor = cpuinfo_get_processor(i);
 		ASSERT_TRUE(processor);
@@ -125,9 +150,11 @@ TEST(PROCESSOR, consistent_l2) {
 			EXPECT_LT(i, l2->processor_start + l2->processor_count);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PROCESSOR, consistent_l3) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
 		const cpuinfo_processor* processor = cpuinfo_get_processor(i);
 		ASSERT_TRUE(processor);
@@ -137,9 +164,11 @@ TEST(PROCESSOR, consistent_l3) {
 			EXPECT_LT(i, l3->processor_start + l3->processor_count);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PROCESSOR, consistent_l4) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_processors_count(); i++) {
 		const cpuinfo_processor* processor = cpuinfo_get_processor(i);
 		ASSERT_TRUE(processor);
@@ -149,34 +178,44 @@ TEST(PROCESSOR, consistent_l4) {
 			EXPECT_LT(i, l4->processor_start + l4->processor_count);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CORES_COUNT, within_bounds) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_NE(0, cpuinfo_get_cores_count());
 	EXPECT_LE(cpuinfo_get_cores_count(), cpuinfo_get_processors_count());
 	EXPECT_GE(cpuinfo_get_cores_count(), cpuinfo_get_packages_count());
+	cpuinfo_deinitialize();
 }
 
 TEST(CORES, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_TRUE(cpuinfo_get_cores());
+	cpuinfo_deinitialize();
 }
 
 TEST(CORE, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
 		EXPECT_TRUE(cpuinfo_get_core(i));
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CORE, non_zero_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
 		const cpuinfo_core* core = cpuinfo_get_core(i);
 		ASSERT_TRUE(core);
 
 		EXPECT_NE(0, core->processor_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CORE, consistent_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
 		const cpuinfo_core* core = cpuinfo_get_core(i);
 		ASSERT_TRUE(core);
@@ -188,9 +227,11 @@ TEST(CORE, consistent_processors) {
 			EXPECT_EQ(core, processor->core);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CORE, valid_core_id) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
 		const cpuinfo_core* core = cpuinfo_get_core(i);
 		ASSERT_TRUE(core);
@@ -199,18 +240,22 @@ TEST(CORE, valid_core_id) {
 
 		EXPECT_LT(core->core_id, package->core_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CORE, valid_cluster) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
 		const cpuinfo_core* core = cpuinfo_get_core(i);
 		ASSERT_TRUE(core);
 
 		EXPECT_TRUE(core->cluster);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CORE, consistent_cluster) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
 		const cpuinfo_core* core = cpuinfo_get_core(i);
 		ASSERT_TRUE(core);
@@ -220,18 +265,22 @@ TEST(CORE, consistent_cluster) {
 		EXPECT_GE(i, cluster->core_start);
 		EXPECT_LT(i, cluster->core_start + cluster->core_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CORE, valid_package) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
 		const cpuinfo_core* core = cpuinfo_get_core(i);
 		ASSERT_TRUE(core);
 
 		EXPECT_TRUE(core->package);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CORE, consistent_package) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
 		const cpuinfo_core* core = cpuinfo_get_core(i);
 		ASSERT_TRUE(core);
@@ -241,53 +290,67 @@ TEST(CORE, consistent_package) {
 		EXPECT_GE(i, package->core_start);
 		EXPECT_LT(i, package->core_start + package->core_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CORE, known_vendor) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
 		const cpuinfo_core* core = cpuinfo_get_core(i);
 		ASSERT_TRUE(core);
 
 		EXPECT_NE(cpuinfo_vendor_unknown, core->vendor);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CORE, known_uarch) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_cores_count(); i++) {
 		const cpuinfo_core* core = cpuinfo_get_core(i);
 		ASSERT_TRUE(core);
 
 		EXPECT_NE(cpuinfo_uarch_unknown, core->uarch);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CLUSTERS_COUNT, within_bounds) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_NE(0, cpuinfo_get_clusters_count());
 	EXPECT_LE(cpuinfo_get_clusters_count(), cpuinfo_get_cores_count());
 	EXPECT_LE(cpuinfo_get_clusters_count(), cpuinfo_get_processors_count());
 	EXPECT_GE(cpuinfo_get_clusters_count(), cpuinfo_get_packages_count());
+	cpuinfo_deinitialize();
 }
 
 TEST(CLUSTERS, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_TRUE(cpuinfo_get_clusters());
+	cpuinfo_deinitialize();
 }
 
 TEST(CLUSTER, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		EXPECT_TRUE(cpuinfo_get_cluster(i));
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CLUSTER, non_zero_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		const cpuinfo_cluster* cluster = cpuinfo_get_cluster(i);
 		ASSERT_TRUE(cluster);
 
 		EXPECT_NE(0, cluster->processor_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CLUSTER, valid_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		const cpuinfo_cluster* cluster = cpuinfo_get_cluster(i);
 		ASSERT_TRUE(cluster);
@@ -295,9 +358,11 @@ TEST(CLUSTER, valid_processors) {
 		EXPECT_LT(cluster->processor_start, cpuinfo_get_processors_count());
 		EXPECT_LE(cluster->processor_start + cluster->processor_count, cpuinfo_get_processors_count());
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CLUSTER, consistent_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		const cpuinfo_cluster* cluster = cpuinfo_get_cluster(i);
 		ASSERT_TRUE(cluster);
@@ -307,18 +372,22 @@ TEST(CLUSTER, consistent_processors) {
 			EXPECT_EQ(cluster, processor->cluster);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CLUSTER, non_zero_cores) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		const cpuinfo_cluster* cluster = cpuinfo_get_cluster(i);
 		ASSERT_TRUE(cluster);
 
 		EXPECT_NE(0, cluster->core_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CLUSTER, valid_cores) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		const cpuinfo_cluster* cluster = cpuinfo_get_cluster(i);
 		ASSERT_TRUE(cluster);
@@ -326,9 +395,11 @@ TEST(CLUSTER, valid_cores) {
 		EXPECT_LT(cluster->core_start, cpuinfo_get_cores_count());
 		EXPECT_LE(cluster->core_start + cluster->core_count, cpuinfo_get_cores_count());
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CLUSTER, consistent_cores) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		const cpuinfo_cluster* cluster = cpuinfo_get_cluster(i);
 		ASSERT_TRUE(cluster);
@@ -340,9 +411,11 @@ TEST(CLUSTER, consistent_cores) {
 			EXPECT_EQ(cluster, core->cluster);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CLUSTER, valid_cluster_id) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		const cpuinfo_cluster* cluster = cpuinfo_get_cluster(i);
 		ASSERT_TRUE(cluster);
@@ -354,18 +427,22 @@ TEST(CLUSTER, valid_cluster_id) {
 			EXPECT_LT(cluster->cluster_id, package->cluster_count);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CLUSTER, valid_package) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		const cpuinfo_cluster* cluster = cpuinfo_get_cluster(i);
 		ASSERT_TRUE(cluster);
 
 		EXPECT_TRUE(cluster->package);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CLUSTER, consistent_package) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		const cpuinfo_cluster* cluster = cpuinfo_get_cluster(i);
 		ASSERT_TRUE(cluster);
@@ -375,9 +452,11 @@ TEST(CLUSTER, consistent_package) {
 		EXPECT_GE(i, package->cluster_start);
 		EXPECT_LT(i, package->cluster_start + package->cluster_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CLUSTER, consistent_vendor) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		const cpuinfo_cluster* cluster = cpuinfo_get_cluster(i);
 		ASSERT_TRUE(cluster);
@@ -389,9 +468,11 @@ TEST(CLUSTER, consistent_vendor) {
 			EXPECT_EQ(cluster->vendor, core->vendor);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(CLUSTER, consistent_uarch) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		const cpuinfo_cluster* cluster = cpuinfo_get_cluster(i);
 		ASSERT_TRUE(cluster);
@@ -403,10 +484,12 @@ TEST(CLUSTER, consistent_uarch) {
 			EXPECT_EQ(cluster->uarch, core->uarch);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 #if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
 TEST(CLUSTER, consistent_cpuid) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		const cpuinfo_cluster* cluster = cpuinfo_get_cluster(i);
 		ASSERT_TRUE(cluster);
@@ -418,11 +501,13 @@ TEST(CLUSTER, consistent_cpuid) {
 			EXPECT_EQ(cluster->cpuid, core->cpuid);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 #endif /* CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64 */
 
 #if CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
 TEST(CLUSTER, consistent_midr) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		const cpuinfo_cluster* cluster = cpuinfo_get_cluster(i);
 		ASSERT_TRUE(cluster);
@@ -434,10 +519,12 @@ TEST(CLUSTER, consistent_midr) {
 			EXPECT_EQ(cluster->midr, core->midr);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 #endif /* CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64 */
 
 TEST(CLUSTER, consistent_frequency) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_clusters_count(); i++) {
 		const cpuinfo_cluster* cluster = cpuinfo_get_cluster(i);
 		ASSERT_TRUE(cluster);
@@ -449,34 +536,44 @@ TEST(CLUSTER, consistent_frequency) {
 			EXPECT_EQ(cluster->frequency, core->frequency);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PACKAGES_COUNT, within_bounds) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_NE(0, cpuinfo_get_packages_count());
 	EXPECT_LE(cpuinfo_get_packages_count(), cpuinfo_get_cores_count());
 	EXPECT_LE(cpuinfo_get_packages_count(), cpuinfo_get_processors_count());
+	cpuinfo_deinitialize();
 }
 
 TEST(PACKAGES, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_TRUE(cpuinfo_get_packages());
+	cpuinfo_deinitialize();
 }
 
 TEST(PACKAGE, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
 		EXPECT_TRUE(cpuinfo_get_package(i));
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PACKAGE, non_zero_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
 		const cpuinfo_package* package = cpuinfo_get_package(i);
 		ASSERT_TRUE(package);
 
 		EXPECT_NE(0, package->processor_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PACKAGE, valid_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
 		const cpuinfo_package* package = cpuinfo_get_package(i);
 		ASSERT_TRUE(package);
@@ -484,9 +581,11 @@ TEST(PACKAGE, valid_processors) {
 		EXPECT_LT(package->processor_start, cpuinfo_get_processors_count());
 		EXPECT_LE(package->processor_start + package->processor_count, cpuinfo_get_processors_count());
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PACKAGE, consistent_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
 		const cpuinfo_package* package = cpuinfo_get_package(i);
 		ASSERT_TRUE(package);
@@ -498,18 +597,22 @@ TEST(PACKAGE, consistent_processors) {
 			EXPECT_EQ(package, processor->package);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PACKAGE, non_zero_cores) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
 		const cpuinfo_package* package = cpuinfo_get_package(i);
 		ASSERT_TRUE(package);
 
 		EXPECT_NE(0, package->core_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PACKAGE, valid_cores) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
 		const cpuinfo_package* package = cpuinfo_get_package(i);
 		ASSERT_TRUE(package);
@@ -517,9 +620,11 @@ TEST(PACKAGE, valid_cores) {
 		EXPECT_LT(package->core_start, cpuinfo_get_cores_count());
 		EXPECT_LE(package->core_start + package->core_count, cpuinfo_get_cores_count());
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PACKAGE, consistent_cores) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
 		const cpuinfo_package* package = cpuinfo_get_package(i);
 		ASSERT_TRUE(package);
@@ -531,18 +636,22 @@ TEST(PACKAGE, consistent_cores) {
 			EXPECT_EQ(package, core->package);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PACKAGE, non_zero_clusters) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
 		const cpuinfo_package* package = cpuinfo_get_package(i);
 		ASSERT_TRUE(package);
 
 		EXPECT_NE(0, package->cluster_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PACKAGE, valid_clusters) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
 		const cpuinfo_package* package = cpuinfo_get_package(i);
 		ASSERT_TRUE(package);
@@ -550,9 +659,11 @@ TEST(PACKAGE, valid_clusters) {
 		EXPECT_LT(package->cluster_start, cpuinfo_get_clusters_count());
 		EXPECT_LE(package->cluster_start + package->cluster_count, cpuinfo_get_clusters_count());
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(PACKAGE, consistent_cluster) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_packages_count(); i++) {
 		const cpuinfo_package* package = cpuinfo_get_package(i);
 		ASSERT_TRUE(package);
@@ -564,33 +675,43 @@ TEST(PACKAGE, consistent_cluster) {
 			EXPECT_EQ(package, cluster->package);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHES_COUNT, within_bounds) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_NE(0, cpuinfo_get_l1i_caches_count());
 	EXPECT_LE(cpuinfo_get_l1i_caches_count(), cpuinfo_get_processors_count());
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHES, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_TRUE(cpuinfo_get_l1i_caches());
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHE, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
 		EXPECT_TRUE(cpuinfo_get_l1i_cache(i));
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHE, non_zero_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1i_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHE, valid_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1i_cache(i);
 		ASSERT_TRUE(cache);
@@ -598,36 +719,44 @@ TEST(L1I_CACHE, valid_size) {
 		EXPECT_EQ(cache->size,
 			cache->associativity * cache->sets * cache->partitions * cache->line_size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHE, non_zero_associativity) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1i_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->associativity);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHE, non_zero_partitions) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1i_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->partitions);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHE, non_zero_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1i_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->line_size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHE, power_of_2_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1i_cache(i);
 		ASSERT_TRUE(cache);
@@ -636,9 +765,11 @@ TEST(L1I_CACHE, power_of_2_line_size) {
 		EXPECT_NE(0, line_size);
 		EXPECT_EQ(0, line_size & (line_size - 1));
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHE, reasonable_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1i_cache(i);
 		ASSERT_TRUE(cache);
@@ -646,9 +777,12 @@ TEST(L1I_CACHE, reasonable_line_size) {
 		EXPECT_GE(cache->line_size, 16);
 		EXPECT_LE(cache->line_size, 128);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHE, valid_flags) {
+	ASSERT_TRUE(cpuinfo_initialize());
+
 	const uint32_t valid_flags = CPUINFO_CACHE_UNIFIED | CPUINFO_CACHE_INCLUSIVE | CPUINFO_CACHE_COMPLEX_INDEXING;
 	for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1i_cache(i);
@@ -656,27 +790,33 @@ TEST(L1I_CACHE, valid_flags) {
 
 		EXPECT_EQ(0, cache->flags & ~valid_flags);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHE, non_inclusive) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1i_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(CPUINFO_CACHE_INCLUSIVE, cache->flags & CPUINFO_CACHE_INCLUSIVE);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHE, non_zero_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1i_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->processor_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHE, valid_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1i_cache(i);
 		ASSERT_TRUE(cache);
@@ -684,9 +824,11 @@ TEST(L1I_CACHE, valid_processors) {
 		EXPECT_LT(cache->processor_start, cpuinfo_get_processors_count());
 		EXPECT_LE(cache->processor_start + cache->processor_count, cpuinfo_get_processors_count());
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1I_CACHE, consistent_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1i_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1i_cache(i);
 		ASSERT_TRUE(cache);
@@ -698,33 +840,43 @@ TEST(L1I_CACHE, consistent_processors) {
 			EXPECT_EQ(cache, processor->cache.l1i);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHES_COUNT, within_bounds) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_NE(0, cpuinfo_get_l1d_caches_count());
 	EXPECT_LE(cpuinfo_get_l1d_caches_count(), cpuinfo_get_processors_count());
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHES, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_TRUE(cpuinfo_get_l1d_caches());
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHE, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
 		EXPECT_TRUE(cpuinfo_get_l1d_cache(i));
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHE, non_zero_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1d_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHE, valid_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1d_cache(i);
 		ASSERT_TRUE(cache);
@@ -732,36 +884,44 @@ TEST(L1D_CACHE, valid_size) {
 		EXPECT_EQ(cache->size,
 			cache->associativity * cache->sets * cache->partitions * cache->line_size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHE, non_zero_associativity) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1d_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->associativity);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHE, non_zero_partitions) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1d_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->partitions);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHE, non_zero_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1d_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->line_size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHE, power_of_2_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1d_cache(i);
 		ASSERT_TRUE(cache);
@@ -770,9 +930,11 @@ TEST(L1D_CACHE, power_of_2_line_size) {
 		EXPECT_NE(0, line_size);
 		EXPECT_EQ(0, line_size & (line_size - 1));
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHE, reasonable_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1d_cache(i);
 		ASSERT_TRUE(cache);
@@ -780,9 +942,12 @@ TEST(L1D_CACHE, reasonable_line_size) {
 		EXPECT_GE(cache->line_size, 16);
 		EXPECT_LE(cache->line_size, 128);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHE, valid_flags) {
+	ASSERT_TRUE(cpuinfo_initialize());
+
 	const uint32_t valid_flags = CPUINFO_CACHE_UNIFIED | CPUINFO_CACHE_INCLUSIVE | CPUINFO_CACHE_COMPLEX_INDEXING;
 	for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1d_cache(i);
@@ -790,27 +955,33 @@ TEST(L1D_CACHE, valid_flags) {
 
 		EXPECT_EQ(0, cache->flags & ~valid_flags);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHE, non_inclusive) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1d_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(CPUINFO_CACHE_INCLUSIVE, cache->flags & CPUINFO_CACHE_INCLUSIVE);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHE, non_zero_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1d_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->processor_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHE, valid_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1d_cache(i);
 		ASSERT_TRUE(cache);
@@ -818,9 +989,11 @@ TEST(L1D_CACHE, valid_processors) {
 		EXPECT_LT(cache->processor_start, cpuinfo_get_processors_count());
 		EXPECT_LE(cache->processor_start + cache->processor_count, cpuinfo_get_processors_count());
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L1D_CACHE, consistent_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l1d_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l1d_cache(i);
 		ASSERT_TRUE(cache);
@@ -832,35 +1005,45 @@ TEST(L1D_CACHE, consistent_processors) {
 			EXPECT_EQ(cache, processor->cache.l1d);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L2_CACHES_COUNT, within_bounds) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_NE(0, cpuinfo_get_l2_caches_count());
 	EXPECT_LE(cpuinfo_get_l2_caches_count(), cpuinfo_get_processors_count());
 	EXPECT_LE(cpuinfo_get_l2_caches_count(), cpuinfo_get_l1d_caches_count());
 	EXPECT_LE(cpuinfo_get_l2_caches_count(), cpuinfo_get_l1i_caches_count());
+	cpuinfo_deinitialize();
 }
 
 TEST(L2_CACHES, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_TRUE(cpuinfo_get_l2_caches());
+	cpuinfo_deinitialize();
 }
 
 TEST(L2_CACHE, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
 		EXPECT_TRUE(cpuinfo_get_l2_cache(i));
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L2_CACHE, non_zero_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l2_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L2_CACHE, valid_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l2_cache(i);
 		ASSERT_TRUE(cache);
@@ -868,36 +1051,44 @@ TEST(L2_CACHE, valid_size) {
 		EXPECT_EQ(cache->size,
 			cache->associativity * cache->sets * cache->partitions * cache->line_size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L2_CACHE, non_zero_associativity) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l2_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->associativity);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L2_CACHE, non_zero_partitions) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l2_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->partitions);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L2_CACHE, non_zero_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l2_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->line_size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L2_CACHE, power_of_2_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l2_cache(i);
 		ASSERT_TRUE(cache);
@@ -906,9 +1097,11 @@ TEST(L2_CACHE, power_of_2_line_size) {
 		EXPECT_NE(0, line_size);
 		EXPECT_EQ(0, line_size & (line_size - 1));
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L2_CACHE, reasonable_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l2_cache(i);
 		ASSERT_TRUE(cache);
@@ -916,9 +1109,12 @@ TEST(L2_CACHE, reasonable_line_size) {
 		EXPECT_GE(cache->line_size, 16);
 		EXPECT_LE(cache->line_size, 128);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L2_CACHE, valid_flags) {
+	ASSERT_TRUE(cpuinfo_initialize());
+
 	const uint32_t valid_flags = CPUINFO_CACHE_UNIFIED | CPUINFO_CACHE_INCLUSIVE | CPUINFO_CACHE_COMPLEX_INDEXING;
 	for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l2_cache(i);
@@ -926,18 +1122,22 @@ TEST(L2_CACHE, valid_flags) {
 
 		EXPECT_EQ(0, cache->flags & ~valid_flags);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L2_CACHE, non_zero_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l2_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->processor_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L2_CACHE, valid_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l2_cache(i);
 		ASSERT_TRUE(cache);
@@ -945,9 +1145,11 @@ TEST(L2_CACHE, valid_processors) {
 		EXPECT_LT(cache->processor_start, cpuinfo_get_processors_count());
 		EXPECT_LE(cache->processor_start + cache->processor_count, cpuinfo_get_processors_count());
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L2_CACHE, consistent_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l2_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l2_cache(i);
 		ASSERT_TRUE(cache);
@@ -959,29 +1161,37 @@ TEST(L2_CACHE, consistent_processors) {
 			EXPECT_EQ(cache, processor->cache.l2);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L3_CACHES_COUNT, within_bounds) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_LE(cpuinfo_get_l3_caches_count(), cpuinfo_get_processors_count());
 	EXPECT_LE(cpuinfo_get_l3_caches_count(), cpuinfo_get_l2_caches_count());
+	cpuinfo_deinitialize();
 }
 
 TEST(L3_CACHE, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l3_caches_count(); i++) {
 		EXPECT_TRUE(cpuinfo_get_l3_cache(i));
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L3_CACHE, non_zero_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l3_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l3_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L3_CACHE, valid_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l3_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l3_cache(i);
 		ASSERT_TRUE(cache);
@@ -989,36 +1199,44 @@ TEST(L3_CACHE, valid_size) {
 		EXPECT_EQ(cache->size,
 			cache->associativity * cache->sets * cache->partitions * cache->line_size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L3_CACHE, non_zero_associativity) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l3_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l3_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->associativity);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L3_CACHE, non_zero_partitions) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l3_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l3_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->partitions);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L3_CACHE, non_zero_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l3_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l3_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->line_size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L3_CACHE, power_of_2_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l3_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l3_cache(i);
 		ASSERT_TRUE(cache);
@@ -1027,9 +1245,11 @@ TEST(L3_CACHE, power_of_2_line_size) {
 		EXPECT_NE(0, line_size);
 		EXPECT_EQ(0, line_size & (line_size - 1));
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L3_CACHE, reasonable_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l3_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l3_cache(i);
 		ASSERT_TRUE(cache);
@@ -1037,9 +1257,12 @@ TEST(L3_CACHE, reasonable_line_size) {
 		EXPECT_GE(cache->line_size, 16);
 		EXPECT_LE(cache->line_size, 128);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L3_CACHE, valid_flags) {
+	ASSERT_TRUE(cpuinfo_initialize());
+
 	const uint32_t valid_flags = CPUINFO_CACHE_UNIFIED | CPUINFO_CACHE_INCLUSIVE | CPUINFO_CACHE_COMPLEX_INDEXING;
 	for (uint32_t i = 0; i < cpuinfo_get_l3_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l3_cache(i);
@@ -1047,18 +1270,22 @@ TEST(L3_CACHE, valid_flags) {
 
 		EXPECT_EQ(0, cache->flags & ~valid_flags);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L3_CACHE, non_zero_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l3_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l3_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->processor_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L3_CACHE, valid_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l3_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l3_cache(i);
 		ASSERT_TRUE(cache);
@@ -1066,9 +1293,11 @@ TEST(L3_CACHE, valid_processors) {
 		EXPECT_LT(cache->processor_start, cpuinfo_get_processors_count());
 		EXPECT_LE(cache->processor_start + cache->processor_count, cpuinfo_get_processors_count());
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L3_CACHE, consistent_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l3_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l3_cache(i);
 		ASSERT_TRUE(cache);
@@ -1080,29 +1309,37 @@ TEST(L3_CACHE, consistent_processors) {
 			EXPECT_EQ(cache, processor->cache.l3);
 		}
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L4_CACHES_COUNT, within_bounds) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	EXPECT_LE(cpuinfo_get_l4_caches_count(), cpuinfo_get_processors_count());
 	EXPECT_LE(cpuinfo_get_l4_caches_count(), cpuinfo_get_l3_caches_count());
+	cpuinfo_deinitialize();
 }
 
 TEST(L4_CACHE, non_null) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l4_caches_count(); i++) {
 		EXPECT_TRUE(cpuinfo_get_l4_cache(i));
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L4_CACHE, non_zero_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l4_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l4_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L4_CACHE, valid_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l4_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l4_cache(i);
 		ASSERT_TRUE(cache);
@@ -1110,36 +1347,44 @@ TEST(L4_CACHE, valid_size) {
 		EXPECT_EQ(cache->size,
 			cache->associativity * cache->sets * cache->partitions * cache->line_size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L4_CACHE, non_zero_associativity) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l4_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l4_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->associativity);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L4_CACHE, non_zero_partitions) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l4_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l4_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->partitions);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L4_CACHE, non_zero_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l4_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l4_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->line_size);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L4_CACHE, power_of_2_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l4_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l4_cache(i);
 		ASSERT_TRUE(cache);
@@ -1148,9 +1393,11 @@ TEST(L4_CACHE, power_of_2_line_size) {
 		EXPECT_NE(0, line_size);
 		EXPECT_EQ(0, line_size & (line_size - 1));
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L4_CACHE, reasonable_line_size) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l4_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l4_cache(i);
 		ASSERT_TRUE(cache);
@@ -1158,9 +1405,12 @@ TEST(L4_CACHE, reasonable_line_size) {
 		EXPECT_GE(cache->line_size, 16);
 		EXPECT_LE(cache->line_size, 128);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L4_CACHE, valid_flags) {
+	ASSERT_TRUE(cpuinfo_initialize());
+
 	const uint32_t valid_flags = CPUINFO_CACHE_UNIFIED | CPUINFO_CACHE_INCLUSIVE | CPUINFO_CACHE_COMPLEX_INDEXING;
 	for (uint32_t i = 0; i < cpuinfo_get_l4_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l4_cache(i);
@@ -1168,18 +1418,22 @@ TEST(L4_CACHE, valid_flags) {
 
 		EXPECT_EQ(0, cache->flags & ~valid_flags);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L4_CACHE, non_zero_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l4_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l4_cache(i);
 		ASSERT_TRUE(cache);
 
 		EXPECT_NE(0, cache->processor_count);
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L4_CACHE, valid_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l4_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l4_cache(i);
 		ASSERT_TRUE(cache);
@@ -1187,9 +1441,11 @@ TEST(L4_CACHE, valid_processors) {
 		EXPECT_LT(cache->processor_start, cpuinfo_get_processors_count());
 		EXPECT_LE(cache->processor_start + cache->processor_count, cpuinfo_get_processors_count());
 	}
+	cpuinfo_deinitialize();
 }
 
 TEST(L4_CACHE, consistent_processors) {
+	ASSERT_TRUE(cpuinfo_initialize());
 	for (uint32_t i = 0; i < cpuinfo_get_l4_caches_count(); i++) {
 		const cpuinfo_cache* cache = cpuinfo_get_l4_cache(i);
 		ASSERT_TRUE(cache);
@@ -1201,10 +1457,5 @@ TEST(L4_CACHE, consistent_processors) {
 			EXPECT_EQ(cache, processor->cache.l4);
 		}
 	}
+	cpuinfo_deinitialize();
 }
-
-int main(int argc, char* argv[]) {
-	cpuinfo_initialize();
-	::testing::InitGoogleTest(&argc, argv);
-	return RUN_ALL_TESTS();
-}
\ No newline at end of file