From 8fce96edd495871769976fef5829dd2743261bda Mon Sep 17 00:00:00 2001
From: Vasant Karasulli <vkarasulli@suse.de>
Date: Fri, 16 Feb 2024 20:19:48 +0100
Subject: [PATCH] log_buffer: add unit tests to test the functionality

Test the log_buffer by calling methods like write_log()
and read_log().

Signed-off-by: Vasant Karasulli <vkarasulli@suse.de>
---
 kernel/src/log_buffer/mod.rs | 92 ++++++++++++++++++++++++++++++++++++
 kernel/src/types.rs          |  5 ++
 2 files changed, 97 insertions(+)

diff --git a/kernel/src/log_buffer/mod.rs b/kernel/src/log_buffer/mod.rs
index 9cacc1a55f..e94b4f4ff5 100644
--- a/kernel/src/log_buffer/mod.rs
+++ b/kernel/src/log_buffer/mod.rs
@@ -9,6 +9,8 @@ use core::fmt::Debug;
 
 use crate::locking::{LockGuard, SpinLock};
 use crate::string::FixedString;
+
+#[cfg(not(test))]
 use crate::types::{LINE_BUFFER_SIZE, PAGE_SIZE};
 use crate::utils::StringRingBuffer;
 
@@ -16,6 +18,7 @@ use alloc::string::ToString;
 use alloc::vec;
 use alloc::vec::Vec;
 
+#[cfg(not(test))]
 const BUF_SIZE: usize = PAGE_SIZE / core::mem::size_of::<char>();
 
 #[derive(Copy, Clone, Debug)]
@@ -65,3 +68,92 @@ pub fn log_buffer() -> LockGuard<'static, LogBuffer> {
 pub fn get_lb() -> &'static SpinLock<LogBuffer> {
     unsafe { &LB }
 }
+
+#[cfg(test)]
+const BUF_SIZE: usize = 64;
+
+#[cfg(test)]
+use crate::types::LINE_BUFFER_SIZE;
+
+#[test]
+fn test_read_write_normal() {
+    let mut fs = FixedString::<LINE_BUFFER_SIZE>::new();
+    for i in 1..=LINE_BUFFER_SIZE {
+        fs.push(char::from_u32(i as u32).unwrap());
+    }
+
+    log_buffer().write_log(&fs);
+
+    let v = log_buffer().read_log();
+    assert_eq!(v.len(), LINE_BUFFER_SIZE);
+    for i in 1..=v.len() {
+        assert_eq!(i as u8, v[i - 1]);
+    }
+}
+
+#[test]
+fn test_read_write_interleaved() {
+    let mut fs = FixedString::<LINE_BUFFER_SIZE>::new();
+    for i in 1..=LINE_BUFFER_SIZE / 2 {
+        fs.push(char::from_u32(i as u32).unwrap());
+    }
+
+    log_buffer().write_log(&fs);
+
+    let v = log_buffer().read_log();
+    assert_eq!(v.len(), LINE_BUFFER_SIZE / 2);
+    for i in 1..=v.len() {
+        assert_eq!(i as u8, v[i - 1]);
+    }
+
+    fs.clear();
+    for i in LINE_BUFFER_SIZE / 2..LINE_BUFFER_SIZE {
+        fs.push(char::from_u32((i + 1) as u32).unwrap());
+    }
+
+    log_buffer().write_log(&fs);
+
+    let v = log_buffer().read_log();
+    assert_eq!(v.len(), LINE_BUFFER_SIZE / 2);
+    for i in 1..v.len() {
+        let val = (i + LINE_BUFFER_SIZE / 2) as u8;
+        assert_eq!(val, v[i - 1]);
+    }
+}
+
+#[test]
+fn test_write_wrap_around() {
+    let mut fs = FixedString::<LINE_BUFFER_SIZE>::new();
+    for i in 1..=LINE_BUFFER_SIZE / 2 {
+        fs.push(char::from_u32(i as u32).unwrap());
+    }
+
+    log_buffer().write_log(&fs);
+
+    let v = log_buffer().read_log();
+    assert_eq!(v.len(), LINE_BUFFER_SIZE / 2);
+    for i in 1..=v.len() {
+        assert_eq!(i as u8, v[i - 1]);
+    }
+
+    fs.clear();
+    for i in 1..=LINE_BUFFER_SIZE {
+        let val = (i + LINE_BUFFER_SIZE / 2) as u32;
+        fs.push(char::from_u32(val).unwrap());
+    }
+
+    log_buffer().write_log(&fs);
+
+    let v = log_buffer().read_log();
+    assert_eq!(v.len(), LINE_BUFFER_SIZE);
+    for i in 1..v.len() {
+        let val = (i + LINE_BUFFER_SIZE / 2) as u8;
+        assert_eq!(val, v[i - 1]);
+    }
+}
+
+#[test]
+fn test_read_empty_buffer() {
+    let v = log_buffer().read_log();
+    assert_eq!(v.len(), 0);
+}
diff --git a/kernel/src/types.rs b/kernel/src/types.rs
index ba38bfbef7..34581f6f24 100644
--- a/kernel/src/types.rs
+++ b/kernel/src/types.rs
@@ -46,4 +46,9 @@ pub const GUEST_VMPL: usize = 2;
 const _: () = assert!(GUEST_VMPL > 0 && GUEST_VMPL < VMPL_MAX);
 
 pub const MAX_CPUS: usize = 512;
+
+#[cfg(not(test))]
 pub const LINE_BUFFER_SIZE: usize = 256;
+
+#[cfg(test)]
+pub const LINE_BUFFER_SIZE: usize = 64;