Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 32e7cafc authored by Dennis Shen's avatar Dennis Shen Committed by Automerger Merge Worker
Browse files

Merge "aconfig: test updates" into main am: d740c503 

Original change: https://android-review.googlesource.com/c/platform/build/+/3021364



Change-Id: I21f0c5acf02227d258a5e12aa0907e552acf638f
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents cf64619c d740c503

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]