common: Include the recordings' size in the listing.

[gps-watch.git] / test / logger_test.rs

diff --git a/test/logger_test.rs b/test/logger_test.rs
index 93568bb3f85ea00f7fe7bbfd4b032d448bbd27b0..cf4984a3d4dd562ec7d642311cc039061d993e60 100644 (file)
--- a/test/logger_test.rs
+++ b/test/logger_test.rs
@@ -80,10 +80,12 @@ impl Pipe {
 
         unsafe {
             extern {
-                fn pipe(pipefd: *mut i32) -> i32;
+                fn pipe2(pipefd: *mut i32, flags: i32) -> i32;
             }
 
-            pipe(pipe_fd.as_mut_ptr());
+            const O_NONBLOCK : i32 = 0x800;
+
+            pipe2(pipe_fd.as_mut_ptr(), O_NONBLOCK);
         }
 
         Pipe {
@@ -349,6 +351,39 @@ fn get_recording_valid() {
     assert!(logger.get_recording(1, &mut yenc_buffer).is_ok());
 }
 
+// Verifies that Logger::list_recordings() shows an empty listing
+// if there are no recordings.
+#[test]
+fn list_recordings0() {
+    let pipe = Pipe::new();
+
+    let mut file = unsafe { std::fs::File::from_raw_fd(pipe.write_fd()) };
+
+    let mut ls_buffer_space = [0u8; 4096];
+    let mut ls_buffer = Buffer::alloc();
+
+    let user_data = (&mut file as *mut std::fs::File) as *mut BufferUserData;
+
+    ls_buffer.init(ls_buffer_space.as_mut_ptr(),
+                   ls_buffer_space.len(),
+                   flush_write_buffer,
+                   user_data);
+
+    let mut fake_storage = FakeStorage::new();
+
+    let mut logger = Logger::new(&mut fake_storage);
+    logger.init();
+
+    logger.list_recordings(&mut ls_buffer);
+
+    let mut file = unsafe { std::fs::File::from_raw_fd(pipe.read_fd()) };
+
+    let mut listing_raw = [0u8; 256];
+
+    // There are no recordings, so there's no data in the pipe either.
+    assert!(file.read(&mut listing_raw).is_err());
+}
+
 // Verifies that Logger::list_recordings() shows a listing
 // of a single recording in the very first sector.
 #[test]
@@ -390,7 +425,59 @@ fn list_recordings1() {
     let num_bytes_read = file.read(&mut listing_raw).unwrap();
 
     let expected_bytes = b"\
-2020-01-07 19:27:30              1\n";
+2020-01-07 19:27:30       4K       1\n";
+
+    assert_eq!(String::from_utf8(expected_bytes.to_vec()).unwrap(),
+               String::from_utf8(listing_raw[0..num_bytes_read].to_vec()).unwrap());
+}
+
+// Verifies that Logger::list_recordings() handles sectors holding
+// additional recording data.
+#[test]
+fn list_recording1_multi_sector() {
+    let pipe = Pipe::new();
+
+    let mut file = unsafe { std::fs::File::from_raw_fd(pipe.write_fd()) };
+
+    let mut ls_buffer_space = [0u8; 4096];
+    let mut ls_buffer = Buffer::alloc();
+
+    let user_data = (&mut file as *mut std::fs::File) as *mut BufferUserData;
+
+    ls_buffer.init(ls_buffer_space.as_mut_ptr(),
+                   ls_buffer_space.len(),
+                   flush_write_buffer,
+                   user_data);
+
+    let mut fake_storage = FakeStorage::new();
+
+    // The first sector starts recording 1.
+    let header0 = [
+        // Header:
+        0x01, 0x00, 0x01, 0x00,
+        0x75, 0x18, 0x17, 0x5e,
+    ];
+
+    // The second sector has additional data for recording 1.
+    let header1 = [
+        0x03, 0x00, 0x01, 0x00,
+    ];
+
+    fake_storage.actual[0..header0.len()].copy_from_slice(&header0);
+    fake_storage.actual[4096..4096 + header1.len()].copy_from_slice(&header1);
+
+    let mut logger = Logger::new(&mut fake_storage);
+    logger.init();
+
+    logger.list_recordings(&mut ls_buffer);
+
+    let mut file = unsafe { std::fs::File::from_raw_fd(pipe.read_fd()) };
+
+    let mut listing_raw = [0u8; 4096];
+    let num_bytes_read = file.read(&mut listing_raw).unwrap();
+
+    let expected_bytes = b"\
+2020-01-09 12:11:33       8K       1\n";
 
     assert_eq!(String::from_utf8(expected_bytes.to_vec()).unwrap(),
                String::from_utf8(listing_raw[0..num_bytes_read].to_vec()).unwrap());