i2pd-launch 0.3.0-beta.2

// src/wipe_tests.rs

#![allow(unused_variables)]
#![allow(unused_imports)]
#![allow(dead_code)]

// Důležité: Importujeme všechny funkce a konstanty z nadřazeného modulu.
// Pro testy makra v odděleném souboru je potřeba `#[macro_use] extern crate`.
// Zde předpokládáme, že název tvého crate je `your_crate_name`.
// #[macro_use]
// extern crate i2pd-launch; // Důležité: Zde použij název tvého crate z Cargo.toml

use super::{wipe_with_zeros, BUFFER_SIZE, BATCH_SIZE}; // delete_file už není potřeba importovat
use std::fs;
use std::io;
use std::io::{Read, Seek, SeekFrom, Write};
use std::path::{Path, PathBuf};

/// Pomocná funkce pro vytvoření dočasného souboru s daným obsahem.
/// Vrací cestu k vytvořenému souboru.
fn create_temp_file(name: &str, content: &[u8]) -> PathBuf {
    let mut path = std::env::temp_dir();
    path.push(name);
    // Zajistíme, že soubor neexistuje z předchozích testů
    if path.exists() {
        let _ = fs::remove_file(&path);
    }
    {
        let mut file = fs::File::create(&path).expect("Failed to create temp file for test");
        file.write_all(content).expect("Failed to write to temp file for test");
    }
    path
}

/// Pomocná funkce pro ověření, zda je soubor naplněn nulami.
fn check_file_for_zeros(path: &Path, expected_original_size: u64) -> bool {
    if !path.exists() {
        return false;
    }
    let mut file = fs::File::open(path).expect("Failed to open file for zero check");
    let metadata = file.metadata().expect("Failed to get metadata for zero check");

    let actual_size = metadata.len();
    if actual_size < expected_original_size {
        return false;
    }

    let mut buffer = vec![0u8; 1024];
    let mut bytes_read_total = 0u64;

    while bytes_read_total < expected_original_size {
        let bytes_to_read = (expected_original_size - bytes_read_total).min(buffer.len() as u64) as usize;
        let bytes_read = file.read(&mut buffer[..bytes_to_read]).expect("Failed to read from file for zero check");
        if bytes_read == 0 {
            return false;
        }

        for i in 0..bytes_read {
            if buffer[i] != 0 {
                println!("Found non-zero byte at offset {}", bytes_read_total + i as u64);
                return false;
            }
        }
        bytes_read_total += bytes_read as u64;
    }
    true
}

// --- Testy pro wipe_with_zeros (pouze přepsání nulami) ---
#[test]
fn test_wipe_with_zeros_small_file() {
    let content = b"Original small data.";
    let path = create_temp_file("wipe_zeros_small.txt", content);
    let original_size = content.len() as u64;

    assert!(wipe_with_zeros(&path).is_ok());
    assert!(path.exists()); // Soubor by po přepsání měl stále existovat
    assert!(check_file_for_zeros(&path, original_size)); // Ověření obsahu nulami
    let _ = fs::remove_file(&path); // Úklid po testu
}

#[test]
fn test_wipe_with_zeros_larger_file() {
    let content = vec![0xAA; BATCH_SIZE * 3 + 500]; // Větší soubor
    let path = create_temp_file("wipe_zeros_large.bin", &content);
    let original_size = content.len() as u64;

    assert!(wipe_with_zeros(&path).is_ok());
    assert!(path.exists());
    assert!(check_file_for_zeros(&path, original_size));
    let _ = fs::remove_file(&path);
}

#[test]
fn test_wipe_with_zeros_non_existent_file_error() {
    let path = PathBuf::from("non_existent_wipe_zeros.txt");
    let result = wipe_with_zeros(&path);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), io::ErrorKind::NotFound);
}

// --- Testy pro makro wipe_and_delete! ---
#[test]
fn test_wipe_and_delete_small_file() {
    let content = b"This data should be wiped and deleted by macro.";
    let path = create_temp_file("macro_wipe_small.txt", content);

    assert!(path.exists());
    // Voláme makro
    assert!(wipe_and_delete!(&path).is_ok());
    assert!(!path.exists()); // Soubor by neměl existovat
}

#[test]
fn test_wipe_and_delete_large_file() {
    let content = vec![0xDE; BUFFER_SIZE + BATCH_SIZE]; // Větší soubor
    let path = create_temp_file("macro_wipe_large.bin", &content);

    assert!(path.exists());
    // Voláme makro
    assert!(wipe_and_delete!(&path).is_ok());
    assert!(!path.exists());
}

#[test]
fn test_wipe_and_delete_non_existent_file_error() {
    let path = PathBuf::from("non_existent_macro_wipe.txt");
    // Voláme makro
    let result = wipe_and_delete!(&path);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), io::ErrorKind::NotFound);
}

#[test]
#[ignore = "Might fail on some systems due to permission issues"]
fn test_wipe_and_delete_read_only_file() {
    let path = create_temp_file("macro_wipe_readonly.txt", b"secret data");
    let mut perms = fs::metadata(&path).unwrap().permissions();
    perms.set_readonly(true);
    fs::set_permissions(&path, perms).unwrap();

    // Voláme makro
    let result = wipe_and_delete!(&path);
    assert!(result.is_ok(), "Failed to wipe read-only file with macro: {:?}", result.unwrap_err());
    assert!(!path.exists());

    // Úklid: Zkusíme nastavit oprávnění zpět a smazat soubor pro případ selhání testu
    if path.exists() {
        let mut perms = fs::metadata(&path).unwrap().permissions();
        perms.set_readonly(false);
        fs::set_permissions(&path, perms).unwrap();
        let _ = fs::remove_file(&path);
    }
}