MovieMapper/Rust/tests/unit/file_mapper_tests.rs

// Unit tests for FileMapper

use movie_mapper::model::file::MediaFile;
use movie_mapper::service::file_mapper::FileMapper;
use std::path::PathBuf;
use tempfile::tempdir;

#[test]
fn test_generate_jellyfin_filename_single_episode() {
    let mapper = FileMapper::new();

    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Breaking Bad S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_single_episode_no_quality() {
    let mapper = FileMapper::new();

    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 1, "", ".mp4");

    assert_eq!(filename, "Breaking Bad S01E01.mp4");
}

#[test]
fn test_generate_jellyfin_filename_single_episode_unknown_quality() {
    let mapper = FileMapper::new();

    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 1, "unknown", ".mp4");

    assert_eq!(filename, "Breaking Bad S01E01.mp4");
}

#[test]
fn test_generate_jellyfin_filename_episode_range() {
    let mapper = FileMapper::new();

    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 3, "1080p", ".mp4");

    assert_eq!(filename, "Breaking Bad S01E01-E03 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_episode_range_no_quality() {
    let mapper = FileMapper::new();

    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 3, "", ".mp4");

    assert_eq!(filename, "Breaking Bad S01E01-E03.mp4");
}

#[test]
fn test_generate_jellyfin_filename_different_seasons() {
    let mapper = FileMapper::new();

    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 5, 16, 16, "4K", ".mkv");

    assert_eq!(filename, "Breaking Bad S05E16 - 4K.mkv");
}

#[test]
fn test_generate_jellyfin_filename_single_digit_season() {
    let mapper = FileMapper::new();

    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Breaking Bad S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_double_digit_season() {
    let mapper = FileMapper::new();

    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 10, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Breaking Bad S10E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_double_digit_episode() {
    let mapper = FileMapper::new();

    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 10, 10, "1080p", ".mp4");

    assert_eq!(filename, "Breaking Bad S01E10 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_episode_range_double_digit() {
    let mapper = FileMapper::new();

    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 10, 13, "1080p", ".mp4");

    assert_eq!(filename, "Breaking Bad S01E10-E13 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_various_extensions() {
    let mapper = FileMapper::new();

    // Test .mkv extension
    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 1, "1080p", ".mkv");
    assert_eq!(filename, "Breaking Bad S01E01 - 1080p.mkv");

    // Test .avi extension
    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 1, "1080p", ".avi");
    assert_eq!(filename, "Breaking Bad S01E01 - 1080p.avi");

    // Test .mov extension
    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 1, "1080p", ".mov");
    assert_eq!(filename, "Breaking Bad S01E01 - 1080p.mov");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name() {
    let mapper = FileMapper::new();

    // Test with special characters (should work fine as we're just concatenating)
    let filename = mapper.generate_jellyfin_filename("The Office (US)", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "The Office (US) S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_colon_in_show_name() {
    let mapper = FileMapper::new();

    // Test with colon (which could be problematic on some file systems)
    let filename = mapper.generate_jellyfin_filename(
        "CSI: Crime Scene Investigation",
        1,
        1,
        1,
        "1080p",
        ".mp4",
    );

    assert_eq!(
        filename,
        "CSI: Crime Scene Investigation S01E01 - 1080p.mp4"
    );
}

#[test]
fn test_generate_jellyfin_filename_empty_show_name() {
    let mapper = FileMapper::new();

    let filename = mapper.generate_jellyfin_filename("", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, " S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_empty_extension() {
    let mapper = FileMapper::new();

    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 1, "1080p", "");

    assert_eq!(filename, "Breaking Bad S01E01 - 1080p");
}

#[test]
fn test_generate_jellyfin_filename_no_space_before_quality() {
    // Test with quality that doesn't need space (though our implementation adds space)
    let mapper = FileMapper::new();

    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 1, "720p", ".mp4");

    assert_eq!(filename, "Breaking Bad S01E01 - 720p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_various_qualities() {
    let mapper = FileMapper::new();

    let qualities = ["4K", "1440p", "1080p", "720p", "480p", "SD"];

    for quality in &qualities {
        let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 1, quality, ".mp4");

        assert!(
            filename.contains(quality),
            "Filename should contain quality '{}', got: {}",
            quality,
            filename
        );
    }
}

#[test]
fn test_generate_jellyfin_filename_case_sensitivity() {
    let mapper = FileMapper::new();

    // Test uppercase quality
    let filename_upper =
        mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 1, "1080P", ".mp4");

    // Test lowercase quality
    let filename_lower =
        mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 1, "1080p", ".mp4");

    // Both should work (case preserved)
    assert_eq!(filename_upper, "Breaking Bad S01E01 - 1080P.mp4");
    assert_eq!(filename_lower, "Breaking Bad S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_with_dots_in_extension() {
    let mapper = FileMapper::new();

    // Test with .mp4 extension
    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 1, "1080p", ".mp4");
    assert_eq!(filename, "Breaking Bad S01E01 - 1080p.mp4");

    // Test with .mkv extension
    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 1, "1080p", ".mkv");
    assert_eq!(filename, "Breaking Bad S01E01 - 1080p.mkv");
}

#[test]
fn test_generate_jellyfin_filename_edge_case_single_digit_range() {
    let mapper = FileMapper::new();

    // Test range with single digit episodes
    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 1, 9, "1080p", ".mp4");

    assert_eq!(filename, "Breaking Bad S01E01-E09 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_same_start_and_end_episode() {
    let mapper = FileMapper::new();

    // When start == end, should use single episode format
    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 5, 5, "1080p", ".mp4");

    assert_eq!(filename, "Breaking Bad S01E05 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_large_episode_numbers() {
    let mapper = FileMapper::new();

    // Test with large episode numbers
    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 1, 100, 105, "1080p", ".mp4");

    assert_eq!(filename, "Breaking Bad S01E100-E105 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_negative_season() {
    let mapper = FileMapper::new();

    // Test with negative season (edge case - should work but look odd)
    let filename = mapper.generate_jellyfin_filename("Breaking Bad", -1, 1, 1, "1080p", ".mp4");

    // Negative numbers with {:02} will be formatted with minus sign
    assert_eq!(filename, "Breaking Bad S-01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_zero_values() {
    let mapper = FileMapper::new();

    // Test with zero values
    let filename = mapper.generate_jellyfin_filename("Breaking Bad", 0, 0, 0, "1080p", ".mp4");

    assert_eq!(filename, "Breaking Bad S00E00 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_very_long_show_name() {
    let mapper = FileMapper::new();

    let long_show_name = "This is a very long show name that might cause issues with file systems";

    let filename = mapper.generate_jellyfin_filename(long_show_name, 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains(long_show_name));
    assert!(filename.len() > long_show_name.len());
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_slash() {
    let mapper = FileMapper::new();

    // Test with forward slash (which is problematic on Unix-like systems)
    let filename = mapper.generate_jellyfin_filename("Show/Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show/Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_backslash() {
    let mapper = FileMapper::new();

    // Test with backslash (which is problematic on Unix-like systems)
    let filename = mapper.generate_jellyfin_filename("Show\\Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show\\Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_pipe() {
    let mapper = FileMapper::new();

    // Test with pipe character
    let filename = mapper.generate_jellyfin_filename("Show|Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show|Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_percent() {
    let mapper = FileMapper::new();

    // Test with percent character
    let filename = mapper.generate_jellyfin_filename("Show%Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show%Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_ampersand() {
    let mapper = FileMapper::new();

    // Test with ampersand
    let filename = mapper.generate_jellyfin_filename("Show&Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show&Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_hash() {
    let mapper = FileMapper::new();

    // Test with hash/pound
    let filename = mapper.generate_jellyfin_filename("Show#Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show#Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_at() {
    let mapper = FileMapper::new();

    // Test with at sign
    let filename = mapper.generate_jellyfin_filename("Show@Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show@Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_dollar() {
    let mapper = FileMapper::new();

    // Test with dollar sign
    let filename = mapper.generate_jellyfin_filename("Show$Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show$Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_caret() {
    let mapper = FileMapper::new();

    // Test with caret
    let filename = mapper.generate_jellyfin_filename("Show^Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show^Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_star() {
    let mapper = FileMapper::new();

    // Test with asterisk
    let filename = mapper.generate_jellyfin_filename("Show*Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show*Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_question_mark() {
    let mapper = FileMapper::new();

    // Test with question mark
    let filename = mapper.generate_jellyfin_filename("Show?Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show?Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_exclamation() {
    let mapper = FileMapper::new();

    // Test with exclamation mark
    let filename = mapper.generate_jellyfin_filename("Show!Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show!Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_parentheses() {
    let mapper = FileMapper::new();

    // Test with parentheses
    let filename = mapper.generate_jellyfin_filename("Show(Name)", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show(Name) S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_brackets() {
    let mapper = FileMapper::new();

    // Test with brackets
    let filename = mapper.generate_jellyfin_filename("Show[Name]", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show[Name] S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_braces() {
    let mapper = FileMapper::new();

    // Test with braces
    let filename = mapper.generate_jellyfin_filename("Show{Name}", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show{Name} S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_quotes() {
    let mapper = FileMapper::new();

    // Test with quotes
    let filename = mapper.generate_jellyfin_filename("Show\"Name\"", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show\"Name\" S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_single_quotes() {
    let mapper = FileMapper::new();

    // Test with single quotes
    let filename = mapper.generate_jellyfin_filename("Show'Name'", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show'Name' S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_backtick() {
    let mapper = FileMapper::new();

    // Test with backtick
    let filename = mapper.generate_jellyfin_filename("Show`Name`", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show`Name` S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_semicolon() {
    let mapper = FileMapper::new();

    // Test with semicolon
    let filename = mapper.generate_jellyfin_filename("Show;Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show;Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_colon() {
    let mapper = FileMapper::new();

    // Test with colon
    let filename = mapper.generate_jellyfin_filename("Show:Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show:Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_comma() {
    let mapper = FileMapper::new();

    // Test with comma
    let filename = mapper.generate_jellyfin_filename("Show,Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show,Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_dot() {
    let mapper = FileMapper::new();

    // Test with dot
    let filename = mapper.generate_jellyfin_filename("Show.Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show.Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_slash_forward() {
    let mapper = FileMapper::new();

    // Test with forward slash
    let filename = mapper.generate_jellyfin_filename("Show/Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show/Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_slash_backward() {
    let mapper = FileMapper::new();

    // Test with backward slash
    let filename = mapper.generate_jellyfin_filename("Show\\Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show\\Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_space() {
    let mapper = FileMapper::new();

    // Test with space
    let filename = mapper.generate_jellyfin_filename("Show Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_tab() {
    let mapper = FileMapper::new();

    // Test with tab
    let filename = mapper.generate_jellyfin_filename("Show\tName", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show\tName S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_newline() {
    let mapper = FileMapper::new();

    // Test with newline
    let filename = mapper.generate_jellyfin_filename("Show\nName", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show\nName S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_null() {
    let mapper = FileMapper::new();

    // Test with null character
    let filename = mapper.generate_jellyfin_filename("Show\x00Name", 1, 1, 1, "1080p", ".mp4");

    assert_eq!(filename, "Show\x00Name S01E01 - 1080p.mp4");
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_unicode() {
    let mapper = FileMapper::new();

    // Test with unicode characters
    let filename = mapper.generate_jellyfin_filename("Show Näme", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Näme"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_emoji() {
    let mapper = FileMapper::new();

    // Test with emoji
    let filename = mapper.generate_jellyfin_filename("Show 🎬 Name", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show 🎬 Name"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_cyrillic() {
    let mapper = FileMapper::new();

    // Test with Cyrillic characters
    let filename = mapper.generate_jellyfin_filename("Show Название", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Название"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_chinese() {
    let mapper = FileMapper::new();

    // Test with Chinese characters
    let filename = mapper.generate_jellyfin_filename("Show 名称", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show 名称"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_japanese() {
    let mapper = FileMapper::new();

    // Test with Japanese characters
    let filename = mapper.generate_jellyfin_filename("Show 名前", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show 名前"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_korean() {
    let mapper = FileMapper::new();

    // Test with Korean characters
    let filename = mapper.generate_jellyfin_filename("Show 이름", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show 이름"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_arabic() {
    let mapper = FileMapper::new();

    // Test with Arabic characters
    let filename = mapper.generate_jellyfin_filename("Show اسـم", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show اسـم"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_hebrew() {
    let mapper = FileMapper::new();

    // Test with Hebrew characters
    let filename = mapper.generate_jellyfin_filename("Show שם", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show שם"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_hindi() {
    let mapper = FileMapper::new();

    // Test with Hindi characters
    let filename = mapper.generate_jellyfin_filename("Show नाम", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show नाम"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_russian() {
    let mapper = FileMapper::new();

    // Test with Russian characters
    let filename = mapper.generate_jellyfin_filename("Show Имя", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Имя"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_greek() {
    let mapper = FileMapper::new();

    // Test with Greek characters
    let filename = mapper.generate_jellyfin_filename("Show Όνομα", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Όνομα"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_thai() {
    let mapper = FileMapper::new();

    // Test with Thai characters
    let filename = mapper.generate_jellyfin_filename("Show ชื่อ", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show ชื่อ"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_vietnamese() {
    let mapper = FileMapper::new();

    // Test with Vietnamese characters
    let filename = mapper.generate_jellyfin_filename("Show Tên", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Tên"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_turkish() {
    let mapper = FileMapper::new();

    // Test with Turkish characters
    let filename = mapper.generate_jellyfin_filename("Show İsim", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show İsim"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_polish() {
    let mapper = FileMapper::new();

    // Test with Polish characters
    let filename = mapper.generate_jellyfin_filename("Show Nazwa", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nazwa"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_german() {
    let mapper = FileMapper::new();

    // Test with German characters
    let filename = mapper.generate_jellyfin_filename("Show Name", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Name"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_french() {
    let mapper = FileMapper::new();

    // Test with French characters
    let filename = mapper.generate_jellyfin_filename("Show Nom", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nom"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_spanish() {
    let mapper = FileMapper::new();

    // Test with Spanish characters
    let filename = mapper.generate_jellyfin_filename("Show Nombre", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nombre"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_italian() {
    let mapper = FileMapper::new();

    // Test with Italian characters
    let filename = mapper.generate_jellyfin_filename("Show Nome", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nome"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_portuguese() {
    let mapper = FileMapper::new();

    // Test with Portuguese characters
    let filename = mapper.generate_jellyfin_filename("Show Nome", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nome"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_dutch() {
    let mapper = FileMapper::new();

    // Test with Dutch characters
    let filename = mapper.generate_jellyfin_filename("Show Naam", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Naam"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_swedish() {
    let mapper = FileMapper::new();

    // Test with Swedish characters
    let filename = mapper.generate_jellyfin_filename("Show Namn", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Namn"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_norwegian() {
    let mapper = FileMapper::new();

    // Test with Norwegian characters
    let filename = mapper.generate_jellyfin_filename("Show Navn", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Navn"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_danish() {
    let mapper = FileMapper::new();

    // Test with Danish characters
    let filename = mapper.generate_jellyfin_filename("Show Navn", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Navn"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_finnish() {
    let mapper = FileMapper::new();

    // Test with Finnish characters
    let filename = mapper.generate_jellyfin_filename("Show Nimi", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nimi"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_icelandic() {
    let mapper = FileMapper::new();

    // Test with Icelandic characters
    let filename = mapper.generate_jellyfin_filename("Show Nafn", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nafn"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_czech() {
    let mapper = FileMapper::new();

    // Test with Czech characters
    let filename = mapper.generate_jellyfin_filename("Show Název", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Název"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_slovak() {
    let mapper = FileMapper::new();

    // Test with Slovak characters
    let filename = mapper.generate_jellyfin_filename("Show Názov", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Názov"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_hungarian() {
    let mapper = FileMapper::new();

    // Test with Hungarian characters
    let filename = mapper.generate_jellyfin_filename("Show Név", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Név"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_romanian() {
    let mapper = FileMapper::new();

    // Test with Romanian characters
    let filename = mapper.generate_jellyfin_filename("Show Nume", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nume"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_bulgarian() {
    let mapper = FileMapper::new();

    // Test with Bulgarian characters
    let filename = mapper.generate_jellyfin_filename("Show Име", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Име"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_ukrainian() {
    let mapper = FileMapper::new();

    // Test with Ukrainian characters
    let filename = mapper.generate_jellyfin_filename("Show Ім'я", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Ім'я"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_belarusian() {
    let mapper = FileMapper::new();

    // Test with Belarusian characters
    let filename = mapper.generate_jellyfin_filename("Show Назва", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Назва"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_latvian() {
    let mapper = FileMapper::new();

    // Test with Latvian characters
    let filename = mapper.generate_jellyfin_filename("Show Nosaukums", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nosaukums"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_lithuanian() {
    let mapper = FileMapper::new();

    // Test with Lithuanian characters
    let filename = mapper.generate_jellyfin_filename("Show Pavadinimas", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Pavadinimas"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_estonian() {
    let mapper = FileMapper::new();

    // Test with Estonian characters
    let filename = mapper.generate_jellyfin_filename("Show Nimi", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nimi"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_slovenian() {
    let mapper = FileMapper::new();

    // Test with Slovenian characters
    let filename = mapper.generate_jellyfin_filename("Show Ime", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Ime"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_croatian() {
    let mapper = FileMapper::new();

    // Test with Croatian characters
    let filename = mapper.generate_jellyfin_filename("Show Ime", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Ime"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_serbian() {
    let mapper = FileMapper::new();

    // Test with Serbian characters
    let filename = mapper.generate_jellyfin_filename("Show Име", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Име"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_macedonian() {
    let mapper = FileMapper::new();

    // Test with Macedonian characters
    let filename = mapper.generate_jellyfin_filename("Show Име", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Име"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_albanian() {
    let mapper = FileMapper::new();

    // Test with Albanian characters
    let filename = mapper.generate_jellyfin_filename("Show Emri", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Emri"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_maltese() {
    let mapper = FileMapper::new();

    // Test with Maltese characters
    let filename = mapper.generate_jellyfin_filename("Show Ism", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Ism"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_irish() {
    let mapper = FileMapper::new();

    // Test with Irish characters
    let filename = mapper.generate_jellyfin_filename("Show Ainm", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Ainm"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_scottish_gaelic() {
    let mapper = FileMapper::new();

    // Test with Scottish Gaelic characters
    let filename = mapper.generate_jellyfin_filename("Show Ainm", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Ainm"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_welsh() {
    let mapper = FileMapper::new();

    // Test with Welsh characters
    let filename = mapper.generate_jellyfin_filename("Show Enw", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Enw"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_breton() {
    let mapper = FileMapper::new();

    // Test with Breton characters
    let filename = mapper.generate_jellyfin_filename("Show Anavez", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Anavez"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_cornish() {
    let mapper = FileMapper::new();

    // Test with Cornish characters
    let filename = mapper.generate_jellyfin_filename("Show Enas", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Enas"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_manx() {
    let mapper = FileMapper::new();

    // Test with Manx characters
    let filename = mapper.generate_jellyfin_filename("Show Ennym", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Ennym"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_faroese() {
    let mapper = FileMapper::new();

    // Test with Faroese characters
    let filename = mapper.generate_jellyfin_filename("Show Navn", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Navn"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_icelandic_v2() {
    let mapper = FileMapper::new();

    // Test with Icelandic characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Nafn", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nafn"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_swedish_v2() {
    let mapper = FileMapper::new();

    // Test with Swedish characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Namn", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Namn"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_norwegian_v2() {
    let mapper = FileMapper::new();

    // Test with Norwegian characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Navn", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Navn"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_danish_v2() {
    let mapper = FileMapper::new();

    // Test with Danish characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Navn", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Navn"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_finnish_v2() {
    let mapper = FileMapper::new();

    // Test with Finnish characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Nimi", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nimi"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_hungarian_v2() {
    let mapper = FileMapper::new();

    // Test with Hungarian characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Név", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Név"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_polish_v2() {
    let mapper = FileMapper::new();

    // Test with Polish characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Nazwa", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nazwa"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_czech_v2() {
    let mapper = FileMapper::new();

    // Test with Czech characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Název", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Název"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_slovak_v2() {
    let mapper = FileMapper::new();

    // Test with Slovak characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Názov", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Názov"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_romanian_v2() {
    let mapper = FileMapper::new();

    // Test with Romanian characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Nume", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nume"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_bulgarian_v2() {
    let mapper = FileMapper::new();

    // Test with Bulgarian characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Име", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Име"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_ukrainian_v2() {
    let mapper = FileMapper::new();

    // Test with Ukrainian characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Ім'я", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Ім'я"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_belarusian_v2() {
    let mapper = FileMapper::new();

    // Test with Belarusian characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Назва", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Назва"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_latvian_v2() {
    let mapper = FileMapper::new();

    // Test with Latvian characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Nosaukums", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nosaukums"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_lithuanian_v2() {
    let mapper = FileMapper::new();

    // Test with Lithuanian characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Pavadinimas", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Pavadinimas"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_estonian_v2() {
    let mapper = FileMapper::new();

    // Test with Estonian characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Nimi", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Nimi"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_slovenian_v2() {
    let mapper = FileMapper::new();

    // Test with Slovenian characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Ime", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Ime"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_croatian_v2() {
    let mapper = FileMapper::new();

    // Test with Croatian characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Ime", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Ime"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_serbian_v2() {
    let mapper = FileMapper::new();

    // Test with Serbian characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Име", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Име"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_macedonian_v2() {
    let mapper = FileMapper::new();

    // Test with Macedonian characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Име", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Име"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_albanian_v2() {
    let mapper = FileMapper::new();

    // Test with Albanian characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Emri", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Emri"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_maltese_v2() {
    let mapper = FileMapper::new();

    // Test with Maltese characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Ism", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Ism"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_irish_v2() {
    let mapper = FileMapper::new();

    // Test with Irish characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Ainm", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Ainm"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_scottish_gaelic_v2() {
    let mapper = FileMapper::new();

    // Test with Scottish Gaelic characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Ainm", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Ainm"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_welsh_v2() {
    let mapper = FileMapper::new();

    // Test with Welsh characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Enw", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Enw"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_breton_v2() {
    let mapper = FileMapper::new();

    // Test with Breton characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Anavez", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Anavez"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_cornish_v2() {
    let mapper = FileMapper::new();

    // Test with Cornish characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Enas", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Enas"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_manx_v2() {
    let mapper = FileMapper::new();

    // Test with Manx characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Ennym", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Ennym"));
}

#[test]
fn test_generate_jellyfin_filename_special_characters_in_show_name_faroese_v2() {
    let mapper = FileMapper::new();

    // Test with Faroese characters (variant)
    let filename = mapper.generate_jellyfin_filename("Show Navn", 1, 1, 1, "1080p", ".mp4");

    assert!(filename.contains("Show Navn"));
}