Upgrade rust/crates/android_logger to 0.10.1 am: c30f4ebc74 am: 16f99b5d29 am: de83e23dcd

Original change: https://android-review.googlesource.com/c/platform/external/rust/crates/android_logger/+/1679486

Change-Id: I42a505b8e00fe103d5d9fb86593435e98c28f691

13 files changed, 345 insertions, 34 deletions

diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index 9c90d15..00435b7 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,5 @@
 {
   "git": {
-    "sha1": "ed772ca806d8ddde99bdc02019224cfa498a5097"
+    "sha1": "c20ec25acacf0731583140b230e6ce94e59b054d"
   }
 }
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..674617d
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,53 @@
+name: Continuous integration
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  ci:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+          - macOS-latest
+        toolchain:
+          - stable
+          - beta
+          - nightly
+        target:
+          - arm-linux-androideabi
+          - armv7-linux-androideabi
+          - aarch64-linux-android
+          - i686-linux-android
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install Rust ${{ matrix.toolchain }}
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.toolchain }}
+          target: ${{ matrix.target }}
+
+      - name: Build
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+
+      - name: Generate docs
+        uses: actions-rs/cargo@v1
+        with:
+          command: doc
+
+      - name: Run tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index af70373..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,25 +0,0 @@
-language: rust
-rust:
-  - stable
-  - beta
-  - nightly
-matrix:
-  allow_failures:
-    - rust: nightly
-os:
-  - linux
-  - osx
-
-before_script:
-  - rustup target add arm-linux-androideabi
-  - rustup target add armv7-linux-androideabi
-  - rustup target add aarch64-linux-android
-  - rustup target add i686-linux-android
-
-script:
-  - cargo check --target=arm-linux-androideabi
-  - cargo check --target=armv7-linux-androideabi
-  - cargo check --target=aarch64-linux-android
-  - cargo check --target=i686-linux-android
-  - cargo doc
-  - cargo test
diff --git a/Android.bp b/Android.bp
index f1937d7..1e4ec18 100644
--- a/Android.bp
+++ b/Android.bp
@@ -58,6 +58,43 @@ rust_test {
     ],
 }
 
+rust_defaults {
+    name: "android_logger_defaults",
+    crate_name: "android_logger",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    edition: "2015",
+    features: [
+        "default",
+        "regex",
+    ],
+    rustlibs: [
+        "libandroid_log_sys",
+        "libandroid_logger",
+        "libenv_logger",
+        "liblazy_static",
+        "liblog_rust",
+    ],
+}
+
+rust_test {
+    name: "android_logger_device_test_tests_config_log_level",
+    defaults: ["android_logger_defaults"],
+    srcs: ["tests/config_log_level.rs"],
+}
+
+rust_test {
+    name: "android_logger_device_test_tests_default_init",
+    defaults: ["android_logger_defaults"],
+    srcs: ["tests/default_init.rs"],
+}
+
+rust_test {
+    name: "android_logger_device_test_tests_multiple_init",
+    defaults: ["android_logger_defaults"],
+    srcs: ["tests/multiple_init.rs"],
+}
+
 rust_library {
     name: "libandroid_logger",
     crate_name: "android_logger",
diff --git a/Cargo.toml b/Cargo.toml
index 4652521..dec0113 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,7 +12,7 @@
 
 [package]
 name = "android_logger"
-version = "0.10.0"
+version = "0.10.1"
 authors = ["The android_logger Developers"]
 description = "A logging implementation for `log` which hooks to android log output.\n"
 readme = "README.md"
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index 9aebc2c..a9ad77f 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,6 +1,6 @@
 [package]
 name = "android_logger"
-version = "0.10.0"
+version = "0.10.1"
 authors = ["The android_logger Developers"]
 license = "MIT OR Apache-2.0"
 readme = "README.md"
diff --git a/METADATA b/METADATA
index 6443955..27e229f 100644
--- a/METADATA
+++ b/METADATA
@@ -7,13 +7,13 @@ third_party {
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/android_logger/android_logger-0.10.0.crate"
+    value: "https://static.crates.io/crates/android_logger/android_logger-0.10.1.crate"
   }
-  version: "0.10.0"
+  version: "0.10.1"
   license_type: NOTICE
   last_upgrade_date {
     year: 2021
     month: 4
-    day: 1
+    day: 19
   }
 }
diff --git a/README.md b/README.md
index 9b2c4a4..c3b88bf 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,8 @@
 ## Send Rust logs to Logcat
 
 [![Version](https://img.shields.io/crates/v/android_logger.svg)](https://crates.io/crates/android_logger)
-[![Build Status](https://travis-ci.org/Nercury/android_logger-rs.svg?branch=master)](https://travis-ci.org/Nercury/android_logger-rs)
+[![CI status](https://github.com/Nercury/android_logger-rs/actions/workflows/ci.yml/badge.svg)](https://github.com/Nercury/android_logger-rs/actions/workflows/ci.yml/)
+
 
 This library is a drop-in replacement for `env_logger`. Instead, it outputs messages to
 android's logcat.
diff --git a/TEST_MAPPING b/TEST_MAPPING
index 8cee718..813e886 100644
--- a/TEST_MAPPING
+++ b/TEST_MAPPING
@@ -2,13 +2,40 @@
 {
   "presubmit": [
     {
-      "name": "keystore2_test"
+      "name": "android_logger_device_test_src_lib"
     },
     {
-      "name": "android_logger_device_test_src_lib"
+      "name": "android_logger_device_test_tests_config_log_level"
+    },
+    {
+      "name": "android_logger_device_test_tests_default_init"
+    },
+    {
+      "name": "android_logger_device_test_tests_multiple_init"
+    },
+    {
+      "name": "doh_unit_test"
     },
     {
       "name": "keystore2_selinux_test"
+    },
+    {
+      "name": "keystore2_test"
+    },
+    {
+      "name": "logger_device_test_config_log_level"
+    },
+    {
+      "name": "logger_device_test_default_init"
+    },
+    {
+      "name": "logger_device_test_env_log_level"
+    },
+    {
+      "name": "logger_device_test_multiple_init"
+    },
+    {
+      "name": "logger_device_unit_tests"
     }
   ]
 }
diff --git a/src/lib.rs b/src/lib.rs
index 82412e8..11a127e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -446,3 +446,190 @@ pub fn init_once(config: Config) {
             .expect("failed to acquire android_log filter lock for write") = config;
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fmt::Write;
+    use std::sync::atomic::{AtomicBool, Ordering};
+
+    #[test]
+    fn check_config_values() {
+        // Filter is checked in config_filter_match below.
+        let config = Config::default()
+            .with_min_level(Level::Trace)
+            .with_tag("my_app");
+
+        assert_eq!(config.log_level, Some(Level::Trace));
+        assert_eq!(config.tag, Some(CString::new("my_app").unwrap()));
+    }
+
+    #[test]
+    fn log_calls_formatter() {
+        static FORMAT_FN_WAS_CALLED: AtomicBool = AtomicBool::new(false);
+        let config = Config::default()
+            .with_min_level(Level::Info)
+            .format(|_, _| {
+                FORMAT_FN_WAS_CALLED.store(true, Ordering::SeqCst);
+                Ok(())
+            });
+        let logger = AndroidLogger::new(config);
+
+        logger.log(&Record::builder().level(Level::Info).build());
+
+        assert!(FORMAT_FN_WAS_CALLED.load(Ordering::SeqCst));
+    }
+
+    #[test]
+    fn logger_always_enabled() {
+        let logger = AndroidLogger::new(Config::default());
+
+        assert!(logger.enabled(&log::MetadataBuilder::new().build()));
+    }
+
+    // Test whether the filter gets called correctly. Not meant to be exhaustive for all filter
+    // options, as these are handled directly by the filter itself.
+    #[test]
+    fn config_filter_match() {
+        let info_record = Record::builder().level(Level::Info).build();
+        let debug_record = Record::builder().level(Level::Debug).build();
+
+        let info_all_filter = env_logger::filter::Builder::new().parse("info").build();
+        let info_all_config = Config::default().with_filter(info_all_filter);
+
+        assert!(info_all_config.filter_matches(&info_record));
+        assert!(!info_all_config.filter_matches(&debug_record));
+    }
+
+    #[test]
+    fn fill_tag_bytes_truncates_long_tag() {
+        let logger = AndroidLogger::new(Config::default());
+        let too_long_tag: [u8; LOGGING_TAG_MAX_LEN + 20] = [b'a'; LOGGING_TAG_MAX_LEN + 20];
+
+        let mut result: [u8; LOGGING_TAG_MAX_LEN + 1] = Default::default();
+        logger.fill_tag_bytes(&mut result, &too_long_tag);
+
+        let mut expected_result = [b'a'; LOGGING_TAG_MAX_LEN - 2].to_vec();
+        expected_result.extend("..\0".as_bytes());
+        assert_eq!(result.to_vec(), expected_result);
+    }
+
+    #[test]
+    fn fill_tag_bytes_keeps_short_tag() {
+        let logger = AndroidLogger::new(Config::default());
+        let short_tag: [u8; 3] = [b'a'; 3];
+
+        let mut result: [u8; LOGGING_TAG_MAX_LEN + 1] = Default::default();
+        logger.fill_tag_bytes(&mut result, &short_tag);
+
+        let mut expected_result = short_tag.to_vec();
+        expected_result.push(0);
+        assert_eq!(result.to_vec()[..4], expected_result);
+    }
+
+    #[test]
+    fn platform_log_writer_init_values() {
+        let tag = CStr::from_bytes_with_nul(b"tag\0").unwrap();
+
+        let writer = PlatformLogWriter::new(Level::Warn, &tag);
+
+        assert_eq!(writer.tag, tag);
+        // Android uses LogPriority instead, which doesn't implement equality checks
+        #[cfg(not(target_os = "android"))]
+        assert_eq!(writer.priority, Level::Warn);
+    }
+
+    #[test]
+    fn temporal_flush() {
+        let mut writer = get_tag_writer();
+
+        writer
+            .write_str("12\n\n567\n90")
+            .expect("Unable to write to PlatformLogWriter");
+
+        assert_eq!(writer.len, 10);
+        writer.temporal_flush();
+        // Should have flushed up until the last newline.
+        assert_eq!(writer.len, 3);
+        assert_eq!(writer.last_newline_index, 0);
+        assert_eq!(&writer.buffer.to_vec()[..writer.len], "\n90".as_bytes());
+
+        writer.temporal_flush();
+        // Should have flushed all remaining bytes.
+        assert_eq!(writer.len, 0);
+        assert_eq!(writer.last_newline_index, 0);
+    }
+
+    #[test]
+    fn flush() {
+        let mut writer = get_tag_writer();
+        writer
+            .write_str("abcdefghij\n\nklm\nnopqr\nstuvwxyz")
+            .expect("Unable to write to PlatformLogWriter");
+
+        writer.flush();
+
+        assert_eq!(writer.last_newline_index, 0);
+        assert_eq!(writer.len, 0);
+    }
+
+    #[test]
+    fn last_newline_index() {
+        let mut writer = get_tag_writer();
+
+        writer
+            .write_str("12\n\n567\n90")
+            .expect("Unable to write to PlatformLogWriter");
+
+        assert_eq!(writer.last_newline_index, 7);
+    }
+
+    #[test]
+    fn output_specified_len_leaves_buffer_unchanged() {
+        let mut writer = get_tag_writer();
+        let log_string = "abcdefghij\n\nklm\nnopqr\nstuvwxyz";
+        writer
+            .write_str(log_string)
+            .expect("Unable to write to PlatformLogWriter");
+
+        writer.output_specified_len(5);
+
+        assert_eq!(
+            writer.buffer[..log_string.len()].to_vec(),
+            log_string.as_bytes()
+        );
+    }
+
+    #[test]
+    fn copy_bytes_to_start() {
+        let mut writer = get_tag_writer();
+        writer
+            .write_str("0123456789")
+            .expect("Unable to write to PlatformLogWriter");
+
+        writer.copy_bytes_to_start(3, 2);
+
+        assert_eq!(writer.buffer[..10].to_vec(), "3423456789".as_bytes());
+    }
+
+    #[test]
+    fn copy_bytes_to_start_nop() {
+        let test_string = "Test_string_with\n\n\n\nnewlines\n";
+        let mut writer = get_tag_writer();
+        writer
+            .write_str(test_string)
+            .expect("Unable to write to PlatformLogWriter");
+
+        writer.copy_bytes_to_start(0, 20);
+        writer.copy_bytes_to_start(10, 0);
+
+        assert_eq!(
+            writer.buffer[..test_string.len()].to_vec(),
+            test_string.as_bytes()
+        );
+    }
+
+    fn get_tag_writer() -> PlatformLogWriter<'static> {
+        PlatformLogWriter::new(Level::Warn, &CStr::from_bytes_with_nul(b"tag\0").unwrap())
+    }
+}
diff --git a/tests/config_log_level.rs b/tests/config_log_level.rs
new file mode 100644
index 0000000..ca6ad59
--- /dev/null
+++ b/tests/config_log_level.rs
@@ -0,0 +1,9 @@
+extern crate android_logger;
+extern crate log;
+
+#[test]
+fn config_log_level() {
+    android_logger::init_once(android_logger::Config::default().with_min_level(log::Level::Trace));
+
+    assert_eq!(log::max_level(), log::LevelFilter::Trace);
+}
\ No newline at end of file
diff --git a/tests/default_init.rs b/tests/default_init.rs
new file mode 100644
index 0000000..e7ca9e2
--- /dev/null
+++ b/tests/default_init.rs
@@ -0,0 +1,10 @@
+extern crate android_logger;
+extern crate log;
+
+#[test]
+fn default_init() {
+    android_logger::init_once(Default::default());
+
+    // android_logger has default log level "off"
+    assert_eq!(log::max_level(), log::LevelFilter::Off);
+}
\ No newline at end of file
diff --git a/tests/multiple_init.rs b/tests/multiple_init.rs
new file mode 100644
index 0000000..99b58c8
--- /dev/null
+++ b/tests/multiple_init.rs
@@ -0,0 +1,12 @@
+extern crate android_logger;
+extern crate log;
+
+#[test]
+fn multiple_init() {
+    android_logger::init_once(android_logger::Config::default().with_min_level(log::Level::Trace));
+
+    // Second initialization should be silently ignored
+    android_logger::init_once(android_logger::Config::default().with_min_level(log::Level::Error));
+
+    assert_eq!(log::max_level(), log::LevelFilter::Trace);
+}
\ No newline at end of file