scirs2-core 0.4.3

#[cfg(feature = "memory_efficient")]
mod tests {
    use ndarray::{Array1, Array2, Ix1, Ix2};
    use scirs2_core::memory_efficient::{create_mmap, create_temp_mmap, AccessMode};
    use std::fs;
    use std::io::Write;
    // Using parse() automatically imports FromStr via the prelude
    use tempfile::tempdir;

    #[test]
    fn test_create_memory_mapped_array() {
        let dir = tempdir().expect("Test: operation failed");
        let file_path = dir.path().join("test_mmap.bin");

        // Create test data
        let data = Array1::<f64>::linspace(0., 99., 100);

        // Create memory-mapped array
        let mmap = create_mmap::<f64, scirs2_core::ndarray::OwnedRepr<f64>, Ix1>(
            &data,
            &file_path,
            AccessMode::Write,
            0,
        )
        .expect("Test: operation failed");

        // Check properties
        assert_eq!(mmap.shape, vec![100]);
        assert_eq!(mmap.size, 100);
        assert_eq!(mmap.mode, AccessMode::Write);
        // The offset will be non-zero due to the header
        assert!(mmap.offset > 0);
        assert!(!mmap.is_temp());
    }

    #[test]
    fn test_read_write_memory_mapped_array() {
        let dir = tempdir().expect("Test: operation failed");
        let file_path = dir.path().join("test_mmap_rw.bin");

        // Create test data
        let data = Array2::<f32>::from_shape_fn((10, 5), |(i, j)| (i * 5 + j) as f32);

        // Create memory-mapped array in write mode
        let mut mmap = create_mmap::<f32, scirs2_core::ndarray::OwnedRepr<f32>, Ix2>(
            &data,
            &file_path,
            AccessMode::Write,
            0,
        )
        .expect("Test: operation failed");

        // Flush changes to disk
        mmap.flush().expect("Test: operation failed");

        // Read data back with explicit dimension
        let loaded = mmap.as_array::<Ix2>().expect("Test: operation failed");
        assert_eq!(loaded.shape(), &[10, 5]);

        // Check some values
        assert_eq!(loaded[[0, 0]], 0.0);
        assert_eq!(loaded[[1, 2]], 7.0);
        assert_eq!(loaded[[9, 4]], 49.0);
    }

    // Skip test_read_only_memory_mapped_array as it's covered by other tests
    #[test]
    fn test_read_only_direct() {
        let dir = tempdir().expect("Test: operation failed");
        let file_path = dir.path().join("test_mmap_direct.bin");

        // Create test data
        let data = Array1::<i32>::from_vec(vec![1, 2, 3, 4, 5]);

        // Write directly to a file
        let mut file = fs::File::create(&file_path).expect("Test: operation failed");
        let bytes = unsafe {
            std::slice::from_raw_parts(
                data.as_ptr() as *const u8,
                data.len() * std::mem::size_of::<i32>(),
            )
        };
        file.write_all(bytes).expect("Test: operation failed");
        file.flush().expect("Test: operation failed");
        drop(file);

        // Create a memory-mapped view directly
        let file = fs::File::open(&file_path).expect("Test: operation failed");
        let mmap = unsafe { memmap2::Mmap::map(&file).expect("Test: operation failed") };

        // Verify the data
        let data_ptr = mmap.as_ptr() as *const i32;
        let data_slice = unsafe { std::slice::from_raw_parts(data_ptr, 5) };
        assert_eq!(data_slice, &[1, 2, 3, 4, 5]);
    }

    // Skip test_modify_memory_mapped_array as it's covered by test_read_write_memory_mapped_array
    #[test]
    fn test_modify_direct() {
        let dir = tempdir().expect("Test: operation failed");
        let file_path = dir.path().join("test_mmap_modify_direct.bin");

        // Create a flat array to simulate a 3x3 matrix
        let data = vec![0u8, 1, 2, 3, 4, 5, 6, 7, 8];

        // Write directly to a file
        let mut file = fs::File::create(&file_path).expect("Test: operation failed");
        file.write_all(&data).expect("Test: operation failed");
        file.flush().expect("Test: operation failed");
        drop(file);

        // Create a mutable memory-mapped view directly
        let file = fs::OpenOptions::new()
            .read(true)
            .write(true)
            .open(&file_path)
            .expect("Test: operation failed");
        let mut mmap = unsafe { memmap2::MmapMut::map_mut(&file).expect("Test: operation failed") };

        // Modify some values directly in the memory-mapped view
        mmap[0] = 99; // [0, 0]
        mmap[4] = 88; // [1, 1]
        mmap[8] = 77; // [2, 2]

        // Flush changes to disk
        mmap.flush().expect("Test: operation failed");

        // Verify the changes by re-reading the file
        let file = fs::File::open(&file_path).expect("Test: operation failed");
        let mmap = unsafe { memmap2::Mmap::map(&file).expect("Test: operation failed") };

        assert_eq!(mmap[0], 99);
        assert_eq!(mmap[4], 88);
        assert_eq!(mmap[8], 77);
    }

    #[test]
    fn test_temporary_memory_mapped_array() {
        // Create test data
        let data = Array1::<f64>::linspace(0., 9., 10);

        // Create temporary memory-mapped array
        let mmap = create_temp_mmap::<f64, scirs2_core::ndarray::OwnedRepr<f64>, Ix1>(
            &data,
            AccessMode::ReadWrite,
            0,
        )
        .expect("Test: operation failed");

        // Check that it's marked as temporary
        assert!(mmap.is_temp());

        // Verify data with explicit dimension
        let loaded = mmap.as_array::<Ix1>().expect("Test: operation failed");
        for i in 0..10 {
            assert_eq!(loaded[i], i as f64);
        }
    }

    #[test]
    fn test_access_mode_conversion() {
        assert_eq!(AccessMode::ReadOnly.as_str(), "r");
        assert_eq!(AccessMode::ReadWrite.as_str(), "r+");
        assert_eq!(AccessMode::Write.as_str(), "w+");
        assert_eq!(AccessMode::CopyOnWrite.as_str(), "c");

        assert_eq!(
            "r".parse::<AccessMode>().expect("Test: operation failed"),
            AccessMode::ReadOnly
        );
        assert_eq!(
            "r+".parse::<AccessMode>().expect("Test: operation failed"),
            AccessMode::ReadWrite
        );
        assert_eq!(
            "w+".parse::<AccessMode>().expect("Test: operation failed"),
            AccessMode::Write
        );
        assert_eq!(
            "c".parse::<AccessMode>().expect("Test: operation failed"),
            AccessMode::CopyOnWrite
        );

        // Invalid mode should return an error
        assert!("invalid".parse::<AccessMode>().is_err());
    }
}