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

Commit 2ea228ef authored by Dennis Shen's avatar Dennis Shen Committed by Gerrit Code Review
Browse files

Merge "aosp: reenable the filtered out test point in atest" into main

parents 997e6577 4f6f1284

tools/aconfig/aconfig_storage_file/Android.bp

+3 −27
Original line number Diff line number Diff line
@@ -47,38 +47,14 @@ genrule { 
    cmd: "rm -f $(out);cp -f $(in) $(out);chmod -w $(out)",

}



genrule {

    name: "rw.package.map",

    out: ["tests/tmp.rw.package.map"],

    srcs: ["tests/package.map"],

    cmd: "rm -f $(out);cp -f $(in) $(out);chmod +w $(out)",

}



genrule {

    name: "rw.flag.map",

    out: ["tests/tmp.rw.flag.map"],

    srcs: ["tests/flag.map"],

    cmd: "rm -f $(out);cp -f $(in) $(out);chmod +w $(out)",

}



genrule {

    name: "rw.flag.val",

    out: ["tests/tmp.rw.flag.val"],

    srcs: ["tests/flag.val"],

    cmd: "rm -f $(out);cp -f $(in) $(out);chmod +w $(out)",

}



rust_test_host {

    name: "aconfig_storage_file.test",

    test_suites: ["general-tests"],

    defaults: ["aconfig_storage_file.defaults"],

    data: [

        ":ro.package.map",

        ":ro.flag.map",

        ":ro.flag.val",

        ":rw.package.map",

        ":rw.flag.map",

        ":rw.flag.val",

        "tests/package.map",

        "tests/flag.map",

        "tests/flag.val",

    ],

}

tools/aconfig/aconfig_storage_file/src/lib.rs

+50 −46
Original line number Diff line number Diff line
@@ -438,32 +438,38 @@ impl ffi::BooleanFlagValueQueryCXX { 
#[cfg(test)]

mod tests {

    use super::*;

    use crate::test_utils::{

        create_temp_storage_files_for_test, get_binary_storage_proto_bytes,

        set_temp_storage_files_to_read_only, write_bytes_to_temp_file,

    };

    use crate::test_utils::{write_storage_text_to_temp_file, TestStorageFileSet};



    fn create_test_storage_files(read_only: bool) -> TestStorageFileSet {

        TestStorageFileSet::new(

            "./tests/package.map",

            "./tests/flag.map",

            "./tests/flag.val",

            read_only,

        )

        .unwrap()

    }



    #[test]

    // this test point locks down flag package offset query

    fn test_package_offset_query() {

        #[cfg(feature = "cargo")]

        create_temp_storage_files_for_test();



        set_temp_storage_files_to_read_only();

        let text_proto = r#"

files {

        let ro_files = create_test_storage_files(true);

        let text_proto = format!(

            r#"

files {{

    version: 0

    container: "system"

    package_map: "./tests/tmp.ro.package.map"

    flag_map: "./tests/tmp.ro.flag.map"

    flag_val: "./tests/tmp.ro.flag.val"

    package_map: "{}"

    flag_map: "{}"

    flag_val: "{}"

    timestamp: 12345

}

"#;

        let binary_proto_bytes = get_binary_storage_proto_bytes(text_proto).unwrap();

        let file = write_bytes_to_temp_file(&binary_proto_bytes).unwrap();

        let file_full_path = file.path().display().to_string();

}}

"#,

            ro_files.package_map.name, ro_files.flag_map.name, ro_files.flag_val.name

        );



        let file = write_storage_text_to_temp_file(&text_proto).unwrap();

        let file_full_path = file.path().display().to_string();

        let package_offset = get_package_offset_impl(

            &file_full_path,

            "system",
@@ -498,24 +504,23 @@ files { 
    #[test]

    // this test point locks down flag offset query

    fn test_flag_offset_query() {

        #[cfg(feature = "cargo")]

        create_temp_storage_files_for_test();



        set_temp_storage_files_to_read_only();

        let text_proto = r#"

files {

        let ro_files = create_test_storage_files(true);

        let text_proto = format!(

            r#"

files {{

    version: 0

    container: "system"

    package_map: "./tests/tmp.ro.package.map"

    flag_map: "./tests/tmp.ro.flag.map"

    flag_val: "./tests/tmp.ro.flag.val"

    package_map: "{}"

    flag_map: "{}"

    flag_val: "{}"

    timestamp: 12345

}

"#;

        let binary_proto_bytes = get_binary_storage_proto_bytes(text_proto).unwrap();

        let file = write_bytes_to_temp_file(&binary_proto_bytes).unwrap();

        let file_full_path = file.path().display().to_string();

}}

"#,

            ro_files.package_map.name, ro_files.flag_map.name, ro_files.flag_val.name

        );



        let file = write_storage_text_to_temp_file(&text_proto).unwrap();

        let file_full_path = file.path().display().to_string();

        let baseline = vec![

            (0, "enabled_ro", 1u16),

            (0, "enabled_rw", 2u16),
@@ -538,24 +543,23 @@ files { 
    #[test]

    // this test point locks down flag offset query

    fn test_flag_value_query() {

        #[cfg(feature = "cargo")]

        create_temp_storage_files_for_test();



        set_temp_storage_files_to_read_only();

        let text_proto = r#"

files {

        let ro_files = create_test_storage_files(true);

        let text_proto = format!(

            r#"

files {{

    version: 0

    container: "system"

    package_map: "./tests/tmp.ro.package.map"

    flag_map: "./tests/tmp.ro.flag.map"

    flag_val: "./tests/tmp.ro.flag.val"

    package_map: "{}"

    flag_map: "{}"

    flag_val: "{}"

    timestamp: 12345

}

"#;

        let binary_proto_bytes = get_binary_storage_proto_bytes(text_proto).unwrap();

        let file = write_bytes_to_temp_file(&binary_proto_bytes).unwrap();

        let file_full_path = file.path().display().to_string();

}}

"#,

            ro_files.package_map.name, ro_files.flag_map.name, ro_files.flag_val.name

        );



        let file = write_storage_text_to_temp_file(&text_proto).unwrap();

        let file_full_path = file.path().display().to_string();

        let baseline: Vec<bool> = vec![false; 8];

        for (offset, expected_value) in baseline.into_iter().enumerate() {

            let flag_value =

tools/aconfig/aconfig_storage_file/src/mapped_file.rs

+78 −62
Original line number Diff line number Diff line
@@ -148,10 +148,7 @@ pub(crate) fn get_mapped_file( 
#[cfg(test)]

mod tests {

    use super::*;

    use crate::test_utils::{

        create_temp_storage_files_for_test, get_binary_storage_proto_bytes,

        set_temp_storage_files_to_read_only, write_bytes_to_temp_file,

    };

    use crate::test_utils::{write_storage_text_to_temp_file, TestStorageFileSet};



    #[test]

    fn test_find_storage_file_location() {
@@ -173,10 +170,8 @@ files { 
    timestamp: 54321

}

"#;

        let binary_proto_bytes = get_binary_storage_proto_bytes(text_proto).unwrap();

        let file = write_bytes_to_temp_file(&binary_proto_bytes).unwrap();

        let file = write_storage_text_to_temp_file(text_proto).unwrap();

        let file_full_path = file.path().display().to_string();



        let file_info = find_container_storage_location(&file_full_path, "system").unwrap();

        assert_eq!(file_info.version(), 0);

        assert_eq!(file_info.container(), "system");
@@ -213,100 +208,121 @@ files { 
        assert_eq!(mmaped_file[..], content[..]);

    }



    fn create_test_storage_files(read_only: bool) -> TestStorageFileSet {

        TestStorageFileSet::new(

            "./tests/package.map",

            "./tests/flag.map",

            "./tests/flag.val",

            read_only,

        )

        .unwrap()

    }



    #[test]

    fn test_mapped_file_contents() {

        #[cfg(feature = "cargo")]

        create_temp_storage_files_for_test();



        set_temp_storage_files_to_read_only();

        let text_proto = r#"

files {

        let ro_files = create_test_storage_files(true);

        let text_proto = format!(

            r#"

files {{

    version: 0

    container: "system"

    package_map: "./tests/tmp.ro.package.map"

    flag_map: "./tests/tmp.ro.flag.map"

    flag_val: "./tests/tmp.ro.flag.val"

    package_map: "{}"

    flag_map: "{}"

    flag_val: "{}"

    timestamp: 12345

}

"#;

        let binary_proto_bytes = get_binary_storage_proto_bytes(text_proto).unwrap();

        let file = write_bytes_to_temp_file(&binary_proto_bytes).unwrap();

        let file_full_path = file.path().display().to_string();

}}

"#,

            ro_files.package_map.name, ro_files.flag_map.name, ro_files.flag_val.name

        );



        let file = write_storage_text_to_temp_file(&text_proto).unwrap();

        let file_full_path = file.path().display().to_string();

        map_and_verify(

            &file_full_path,

            StorageFileSelection::PackageMap,

            "./tests/tmp.ro.package.map",

            &ro_files.package_map.name,

        );

        map_and_verify(&file_full_path, StorageFileSelection::FlagMap, "./tests/tmp.ro.flag.map");

        map_and_verify(&file_full_path, StorageFileSelection::FlagVal, "./tests/tmp.ro.flag.val");

        map_and_verify(&file_full_path, StorageFileSelection::FlagMap, &ro_files.flag_map.name);

        map_and_verify(&file_full_path, StorageFileSelection::FlagVal, &ro_files.flag_val.name);

    }



    #[test]

    #[cfg(feature = "cargo")]

    fn test_map_non_read_only_file() {

        #[cfg(feature = "cargo")]

        create_temp_storage_files_for_test();



        set_temp_storage_files_to_read_only();

        let text_proto = r#"

files {

        let ro_files = create_test_storage_files(true);

        let rw_files = create_test_storage_files(false);

        let text_proto = format!(

            r#"

files {{

    version: 0

    container: "system"

    package_map: "./tests/tmp.rw.package.map"

    flag_map: "./tests/tmp.rw.flag.map"

    flag_val: "./tests/tmp.rw.flag.val"

    package_map: "{}"

    flag_map: "{}"

    flag_val: "{}"

    timestamp: 12345

}

"#;

        let binary_proto_bytes = get_binary_storage_proto_bytes(text_proto).unwrap();

        let file = write_bytes_to_temp_file(&binary_proto_bytes).unwrap();

        let file_full_path = file.path().display().to_string();

}}

"#,

            rw_files.package_map.name, ro_files.flag_map.name, ro_files.flag_val.name

        );



        let file = write_storage_text_to_temp_file(&text_proto).unwrap();

        let file_full_path = file.path().display().to_string();

        let error = map_container_storage_files(&file_full_path, "system").unwrap_err();

        assert_eq!(

            format!("{:?}", error),

            "MapFileFail(fail to map non read only storage file ./tests/tmp.rw.package.map)"

            format!(

                "MapFileFail(fail to map non read only storage file {})",

                rw_files.package_map.name

            )

        );



        let text_proto = r#"

files {

        let text_proto = format!(

            r#"

files {{

    version: 0

    container: "system"

    package_map: "./tests/tmp.ro.package.map"

    flag_map: "./tests/tmp.rw.flag.map"

    flag_val: "./tests/tmp.rw.flag.val"

    package_map: "{}"

    flag_map: "{}"

    flag_val: "{}"

    timestamp: 12345

}

"#;

        let binary_proto_bytes = get_binary_storage_proto_bytes(text_proto).unwrap();

        let file = write_bytes_to_temp_file(&binary_proto_bytes).unwrap();

        let file_full_path = file.path().display().to_string();

}}

"#,

            ro_files.package_map.name, rw_files.flag_map.name, ro_files.flag_val.name

        );



        let file = write_storage_text_to_temp_file(&text_proto).unwrap();

        let file_full_path = file.path().display().to_string();

        let error = map_container_storage_files(&file_full_path, "system").unwrap_err();

        assert_eq!(

            format!("{:?}", error),

            "MapFileFail(fail to map non read only storage file ./tests/tmp.rw.flag.map)"

            format!(

                "MapFileFail(fail to map non read only storage file {})",

                rw_files.flag_map.name

            )

        );



        let text_proto = r#"

files {

        let text_proto = format!(

            r#"

files {{

    version: 0

    container: "system"

    package_map: "./tests/tmp.ro.package.map"

    flag_map: "./tests/tmp.ro.flag.map"

    flag_val: "./tests/tmp.rw.flag.val"

    package_map: "{}"

    flag_map: "{}"

    flag_val: "{}"

    timestamp: 12345

}

"#;

        let binary_proto_bytes = get_binary_storage_proto_bytes(text_proto).unwrap();

        let file = write_bytes_to_temp_file(&binary_proto_bytes).unwrap();

        let file_full_path = file.path().display().to_string();

}}

"#,

            ro_files.package_map.name, ro_files.flag_map.name, rw_files.flag_val.name

        );



        let file = write_storage_text_to_temp_file(&text_proto).unwrap();

        let file_full_path = file.path().display().to_string();

        let error = map_container_storage_files(&file_full_path, "system").unwrap_err();

        assert_eq!(

            format!("{:?}", error),

            "MapFileFail(fail to map non read only storage file ./tests/tmp.rw.flag.val)"

            format!(

                "MapFileFail(fail to map non read only storage file {})",

                rw_files.flag_val.name

            )

        );

    }

}

tools/aconfig/aconfig_storage_file/src/test_utils.rs

+48 −46
Original line number Diff line number Diff line
@@ -19,12 +19,8 @@ use anyhow::Result; 
use protobuf::Message;

use std::fs;

use std::io::Write;

use std::path::Path;

use std::sync::Once;

use tempfile::NamedTempFile;



static INIT: Once = Once::new();



pub(crate) fn get_binary_storage_proto_bytes(text_proto: &str) -> Result<Vec<u8>> {

    let storage_files: ProtoStorageFiles = protobuf::text_format::parse_from_str(text_proto)?;

    let mut binary_proto = Vec::new();
@@ -32,59 +28,65 @@ pub(crate) fn get_binary_storage_proto_bytes(text_proto: &str) -> Result<Vec<u8> 
    Ok(binary_proto)

}



pub(crate) fn write_bytes_to_temp_file(bytes: &[u8]) -> Result<NamedTempFile> {

pub(crate) fn write_storage_text_to_temp_file(text_proto: &str) -> Result<NamedTempFile> {

    let bytes = get_binary_storage_proto_bytes(text_proto).unwrap();

    let mut file = NamedTempFile::new()?;

    let _ = file.write_all(&bytes);

    Ok(file)

}



fn has_same_content(file1: &Path, file2: &Path) -> Result<bool> {

    let bytes1 = fs::read(file1)?;

    let bytes2 = fs::read(file2)?;

    if bytes1.len() != bytes2.len() {

        return Ok(false);

fn set_file_read_only(file: &NamedTempFile) {

    let mut perms = fs::metadata(file.path()).unwrap().permissions();

    if !perms.readonly() {

        perms.set_readonly(true);

        fs::set_permissions(file.path(), perms).unwrap();

    }

    for (i, &b1) in bytes1.iter().enumerate() {

        if b1 != bytes2[i] {

            return Ok(false);

}



fn set_file_read_write(file: &NamedTempFile) {

    let mut perms = fs::metadata(file.path()).unwrap().permissions();

    if perms.readonly() {

        perms.set_readonly(false);

        fs::set_permissions(file.path(), perms).unwrap();

    }

    Ok(true)

}



pub(crate) fn create_temp_storage_files_for_test() {

    INIT.call_once(|| {

        let file_paths = [

            ("./tests/package.map", "./tests/tmp.ro.package.map"),

            ("./tests/flag.map", "./tests/tmp.ro.flag.map"),

            ("./tests/flag.val", "./tests/tmp.ro.flag.val"),

            ("./tests/package.map", "./tests/tmp.rw.package.map"),

            ("./tests/flag.map", "./tests/tmp.rw.flag.map"),

            ("./tests/flag.val", "./tests/tmp.rw.flag.val"),

        ];

        for (file_path, copied_file_path) in file_paths.into_iter() {

            let file_path = Path::new(&file_path);

            let copied_file_path = Path::new(&copied_file_path);

            if copied_file_path.exists() && !has_same_content(file_path, copied_file_path).unwrap()

            {

                fs::remove_file(copied_file_path).unwrap();

pub(crate) struct TestStorageFile {

    pub file: NamedTempFile,

    pub name: String,

}

            if !copied_file_path.exists() {

                fs::copy(file_path, copied_file_path).unwrap();



impl TestStorageFile {

    pub(crate) fn new(source_file: &str, read_only: bool) -> Result<Self> {

        let file = NamedTempFile::new()?;

        fs::copy(source_file, file.path())?;

        if read_only {

            set_file_read_only(&file);

        } else {

            set_file_read_write(&file);

        }

        let name = file.path().display().to_string();

        Ok(Self { file, name })

    }

    });

}



pub(crate) fn set_temp_storage_files_to_read_only() {

    let file_paths =

        ["./tests/tmp.ro.package.map", "./tests/tmp.ro.flag.map", "./tests/tmp.ro.flag.val"];

    for file_path in file_paths.into_iter() {

        let file_path = Path::new(&file_path);

        let mut perms = fs::metadata(file_path).unwrap().permissions();

        if !perms.readonly() {

            perms.set_readonly(true);

            fs::set_permissions(file_path, perms).unwrap();

pub(crate) struct TestStorageFileSet {

    pub package_map: TestStorageFile,

    pub flag_map: TestStorageFile,

    pub flag_val: TestStorageFile,

}



impl TestStorageFileSet {

    pub(crate) fn new(

        package_map_path: &str,

        flag_map_path: &str,

        flag_val_path: &str,

        read_only: bool,

    ) -> Result<Self> {

        Ok(Self {

            package_map: TestStorageFile::new(package_map_path, read_only)?,

            flag_map: TestStorageFile::new(flag_map_path, read_only)?,

            flag_val: TestStorageFile::new(flag_val_path, read_only)?,

        })

    }

}