#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_striped_download() -> anyhow::Result<()> {
        const MB: usize = 1024 * 1024;
        let bucket_name = "projects/_/buckets/my_bucket";
        let destination_single = "/tmp/striped_download_single.txt";
        let destination_striped = "/tmp/striped_download_striped.txt";

        let client = Storage::builder().build().await?;
        let control = StorageControl::builder().build().await?;

        seed(client.clone(), control.clone(), bucket_name).await?;

        // Download with large stripe size (single stripe)
        println!("\n--- Download with 32 MiB stripe (single stripe) ---");
        download(
            client.clone(),
            control.clone(),
            bucket_name,
            "32MiB.txt",
            32 * MB,
            destination_single,
        )
        .await?;

        // Download with small stripe size (32 stripes)
        println!("\n--- Download with 1 MiB stripe (32 stripes) ---");
        download(
            client.clone(),
            control.clone(),
            bucket_name,
            "32MiB.txt",
            MB,
            destination_striped,
        )
        .await?;

        // Compute and compare hashes
        println!("\n--- Computing hashes ---");
        let hash_single = compute_sha256(destination_single).await?;
        let hash_striped = compute_sha256(destination_striped).await?;

        println!("Hash (single stripe):  {}", hash_single);
        println!("Hash (32 stripes):     {}", hash_striped);

        assert_eq!(
            hash_single, hash_striped,
            "Hashes don't match! Files are different."
        );
        println!("\n✓ Hashes match! Files are identical.");

        // Clean up
        std::fs::remove_file(destination_single).ok();
        std::fs::remove_file(destination_striped).ok();

        Ok(())
    }

    async fn compute_sha256(file_path: &str) -> anyhow::Result<String> {
        use sha2::{Digest, Sha256};
        use tokio::io::AsyncReadExt;

        let mut file = tokio::fs::File::open(file_path).await?;
        let mut hasher = Sha256::new();
        let mut buffer = vec![0u8; 8192];

        loop {
            let n = file.read(&mut buffer).await?;
            if n == 0 {
                break;
            }
            hasher.update(&buffer[..n]);
        }

        let result = hasher.finalize();
        Ok(format!("{:x}", result))
    }
}