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

Commit 3e4c33c1 authored by Dennis Shen's avatar Dennis Shen
Browse files

aconfig: test updates 

Previously, three seperate crates create their own test baseline which
are nearly identical. This is inconvinent when updating the baselines.
All three locations needs to be touched. This cl merges functions to
create test storage file base struct into aconfig_storage_file crate

Bug: b/321077378
Test: atest aconfig.test
Change-Id: Ic97437f856763347a11de8b449592292014bcce3
parent cd381f5d

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]