Merge "aconfig: test updates" into main (d740c503) · Commits · e / os / android_build

tools/aconfig/aconfig/src/storage/flag_table.rs

+5 −66

Original line number	Diff line number	Diff line
		@@ -141,79 +141,18 @@ mod tests {
		use super::*;
		use crate::storage::{group_flags_by_package, tests::parse_all_test_flags};

		// create test baseline, syntactic sugar
		fn new_expected_node(
		package_id: u32,
		flag_name: &str,
		flag_type: u16,
		flag_id: u16,
		next_offset: Option<u32>,
		) -> FlagTableNode {
		FlagTableNode {
		package_id,
		flag_name: flag_name.to_string(),
		flag_type: StoredFlagType::try_from(flag_type).unwrap(),
		flag_id,
		next_offset,
		}
		}

		fn create_test_flag_table() -> Result<FlagTable> {
		fn create_test_flag_table_from_source() -> Result<FlagTable> {
		let caches = parse_all_test_flags();
		let packages = group_flags_by_package(caches.iter());
		create_flag_table("system", &packages)
		create_flag_table("mockup", &packages)
		}

		#[test]
		// this test point locks down the table creation and each field
		fn test_table_contents() {
		let flag_table = create_test_flag_table();
		let flag_table = create_test_flag_table_from_source();
		assert!(flag_table.is_ok());

		let header: &FlagTableHeader = &flag_table.as_ref().unwrap().header;
		let expected_header = FlagTableHeader {
		version: FILE_VERSION,
		container: String::from("system"),
		file_type: StorageFileType::FlagMap as u8,
		file_size: 321,
		num_flags: 8,
		bucket_offset: 31,
		node_offset: 99,
		};
		assert_eq!(header, &expected_header);

		let buckets: &Vec<Option<u32>> = &flag_table.as_ref().unwrap().buckets;
		let expected_bucket: Vec<Option<u32>> = vec![
		Some(99),
		Some(125),
		None,
		None,
		None,
		Some(178),
		None,
		Some(204),
		None,
		Some(262),
		None,
		None,
		None,
		None,
		None,
		Some(294),
		None,
		];
		assert_eq!(buckets, &expected_bucket);

		let nodes: &Vec<FlagTableNode> = &flag_table.as_ref().unwrap().nodes;
		assert_eq!(nodes.len(), 8);

		assert_eq!(nodes[0], new_expected_node(0, "enabled_ro", 1, 1, None));
		assert_eq!(nodes[1], new_expected_node(0, "enabled_rw", 0, 2, Some(151)));
		assert_eq!(nodes[2], new_expected_node(1, "disabled_ro", 1, 0, None));
		assert_eq!(nodes[3], new_expected_node(2, "enabled_ro", 1, 1, None));
		assert_eq!(nodes[4], new_expected_node(1, "enabled_fixed_ro", 2, 1, Some(236)));
		assert_eq!(nodes[5], new_expected_node(1, "enabled_ro", 1, 2, None));
		assert_eq!(nodes[6], new_expected_node(2, "enabled_fixed_ro", 2, 0, None));
		assert_eq!(nodes[7], new_expected_node(0, "disabled_rw", 0, 0, None));
		let expected_flag_table = aconfig_storage_file::test_utils::create_test_flag_table();
		assert_eq!(flag_table.unwrap(), expected_flag_table);
		}
		}

tools/aconfig/aconfig/src/storage/flag_value.rs

+6 −18

Original line number	Diff line number	Diff line
		@@ -64,31 +64,19 @@ mod tests {
		use super::*;
		use crate::storage::{group_flags_by_package, tests::parse_all_test_flags};

		pub fn create_test_flag_value_list() -> Result<FlagValueList> {
		pub fn create_test_flag_value_list_from_source() -> Result<FlagValueList> {
		let caches = parse_all_test_flags();
		let packages = group_flags_by_package(caches.iter());
		create_flag_value("system", &packages)
		create_flag_value("mockup", &packages)
		}

		#[test]
		// this test point locks down the flag value creation and each field
		fn test_list_contents() {
		let flag_value_list = create_test_flag_value_list();
		let flag_value_list = create_test_flag_value_list_from_source();
		assert!(flag_value_list.is_ok());

		let header: &FlagValueHeader = &flag_value_list.as_ref().unwrap().header;
		let expected_header = FlagValueHeader {
		version: FILE_VERSION,
		container: String::from("system"),
		file_type: StorageFileType::FlagVal as u8,
		file_size: 35,
		num_flags: 8,
		boolean_value_offset: 27,
		};
		assert_eq!(header, &expected_header);

		let booleans: &Vec<bool> = &flag_value_list.as_ref().unwrap().booleans;
		let expected_booleans: Vec<bool> = vec![false, true, true, false, true, true, true, true];
		assert_eq!(booleans, &expected_booleans);
		let expected_flag_value_list =
		aconfig_storage_file::test_utils::create_test_flag_value_list();
		assert_eq!(flag_value_list.unwrap(), expected_flag_value_list);
		}
		}

tools/aconfig/aconfig/src/storage/package_table.rs

+5 −43

Original line number	Diff line number	Diff line
		@@ -109,56 +109,18 @@ mod tests {
		use super::*;
		use crate::storage::{group_flags_by_package, tests::parse_all_test_flags};

		pub fn create_test_package_table() -> Result<PackageTable> {
		pub fn create_test_package_table_from_source() -> Result<PackageTable> {
		let caches = parse_all_test_flags();
		let packages = group_flags_by_package(caches.iter());
		create_package_table("system", &packages)
		create_package_table("mockup", &packages)
		}

		#[test]
		// this test point locks down the table creation and each field
		fn test_table_contents() {
		let package_table = create_test_package_table();
		let package_table = create_test_package_table_from_source();
		assert!(package_table.is_ok());

		let header: &PackageTableHeader = &package_table.as_ref().unwrap().header;
		let expected_header = PackageTableHeader {
		version: FILE_VERSION,
		container: String::from("system"),
		file_type: StorageFileType::PackageMap as u8,
		file_size: 209,
		num_packages: 3,
		bucket_offset: 31,
		node_offset: 59,
		};
		assert_eq!(header, &expected_header);

		let buckets: &Vec<Option<u32>> = &package_table.as_ref().unwrap().buckets;
		let expected: Vec<Option<u32>> = vec![Some(59), None, None, Some(109), None, None, None];
		assert_eq!(buckets, &expected);

		let nodes: &Vec<PackageTableNode> = &package_table.as_ref().unwrap().nodes;
		assert_eq!(nodes.len(), 3);
		let first_node_expected = PackageTableNode {
		package_name: String::from("com.android.aconfig.storage.test_2"),
		package_id: 1,
		boolean_offset: 3,
		next_offset: None,
		};
		assert_eq!(nodes[0], first_node_expected);
		let second_node_expected = PackageTableNode {
		package_name: String::from("com.android.aconfig.storage.test_1"),
		package_id: 0,
		boolean_offset: 0,
		next_offset: Some(159),
		};
		assert_eq!(nodes[1], second_node_expected);
		let third_node_expected = PackageTableNode {
		package_name: String::from("com.android.aconfig.storage.test_4"),
		package_id: 2,
		boolean_offset: 6,
		next_offset: None,
		};
		assert_eq!(nodes[2], third_node_expected);
		let expected_package_table = aconfig_storage_file::test_utils::create_test_package_table();
		assert_eq!(package_table.unwrap(), expected_package_table);
		}
		}

tools/aconfig/aconfig_storage_file/src/flag_table.rs

+1 −1

Original line number	Diff line number	Diff line
		@@ -251,7 +251,7 @@ mod tests {
		let bytes = &flag_table.into_bytes();
		let mut head = 0;
		let version = read_u32_from_bytes(bytes, &mut head).unwrap();
		assert_eq!(version, 1234)
		assert_eq!(version, 1);
		}

		#[test]

tools/aconfig/aconfig_storage_file/src/flag_value.rs

+1 −1

Original line number	Diff line number	Diff line
		@@ -158,7 +158,7 @@ mod tests {
		let bytes = &flag_value_list.into_bytes();
		let mut head = 0;
		let version = read_u32_from_bytes(bytes, &mut head).unwrap();
		assert_eq!(version, 1234)
		assert_eq!(version, 1);
		}

		#[test]