Merge pull request #41 from BramBonne/add-tests

Add tests

Author: Nercury

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())
+    }
+}

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);
+}

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);
+}

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);
+}