ass-core 0.1.2

High-performance ASS subtitle format parser and analyzer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Tests for the realistic-preset generators and the standalone script
//! builder functions (`create_test_event`, issue and overlap generators).

use super::*;
use crate::parser::ast::EventType;

#[test]
fn create_test_event_basic() {
    let event = create_test_event("0:00:00.00", "0:00:05.00", "Test text");
    assert_eq!(event.start, "0:00:00.00");
    assert_eq!(event.end, "0:00:05.00");
    assert_eq!(event.text, "Test text");
    assert_eq!(event.style, "Default");
    assert!(matches!(event.event_type, EventType::Dialogue));
}

#[test]
fn generate_script_with_issues_basic() {
    let script = generate_script_with_issues(5);
    assert!(script.contains("[Script Info]"));
    assert!(script.contains("[V4+ Styles]"));
    assert!(script.contains("[Events]"));
    assert!(script.contains("Dialogue:"));
}

#[test]
fn generate_script_with_issues_contains_problems() {
    let script = generate_script_with_issues(20);
    // Should contain some problematic content
    assert!(script.lines().count() > 10);
    // At least one event should have issues (every 10th event)
    assert!(script.contains("empty tag") || script.contains("unknown tag"));
}

#[test]
fn generate_overlapping_script_basic() {
    let script = generate_overlapping_script(3);
    assert!(script.contains("[V4+ Styles]"));
    assert!(script.contains("[Events]"));
    assert!(script.contains("Event 0 text"));
    assert!(script.contains("Event 1 text"));
    assert!(script.contains("Event 2 text"));
}

#[test]
fn generate_overlapping_script_timing() {
    let script = generate_overlapping_script(2);
    // First event: 0:00:00.00 to 0:00:05.00
    // Second event: 0:00:02.00 to 0:00:07.00 (overlaps with first)
    assert!(script.contains("0:00:00.00"));
    assert!(script.contains("0:00:05.00"));
    assert!(script.contains("0:00:02.00"));
    assert!(script.contains("0:00:07.00"));
}

#[test]
fn anime_realistic_generator() {
    let generator = ScriptGenerator::anime_realistic(5);
    assert_eq!(generator.events_count, 5);
    assert_eq!(generator.styles_count, 15);
    assert!(matches!(
        generator.complexity_level,
        ComplexityLevel::AnimeRealistic
    ));

    let script = generator.generate();
    assert!(script.contains("Anime Subtitles"));
}

#[test]
fn movie_realistic_generator() {
    let generator = ScriptGenerator::movie_realistic(3);
    assert_eq!(generator.events_count, 3);
    assert_eq!(generator.styles_count, 3);
    assert!(matches!(
        generator.complexity_level,
        ComplexityLevel::MovieRealistic
    ));
}

#[test]
fn karaoke_realistic_generator() {
    let generator = ScriptGenerator::karaoke_realistic(2);
    assert_eq!(generator.events_count, 2);
    assert_eq!(generator.styles_count, 8);
    assert!(matches!(
        generator.complexity_level,
        ComplexityLevel::KaraokeRealistic
    ));

    let text = generator.generate_dialogue_text(0);
    assert!(text.contains(r"{\k"));
}

#[test]
fn sign_realistic_generator() {
    let generator = ScriptGenerator::sign_realistic(4);
    assert_eq!(generator.events_count, 4);
    assert_eq!(generator.styles_count, 12);
    assert!(matches!(
        generator.complexity_level,
        ComplexityLevel::SignRealistic
    ));

    let text = generator.generate_dialogue_text(0);
    assert!(text.contains(r"{\pos(") || text.contains(r"{\an"));
}

#[test]
fn educational_realistic_generator() {
    let generator = ScriptGenerator::educational_realistic(6);
    assert_eq!(generator.events_count, 6);
    assert_eq!(generator.styles_count, 6);
    assert!(matches!(
        generator.complexity_level,
        ComplexityLevel::EducationalRealistic
    ));

    let text = generator.generate_dialogue_text(1);
    assert!(text.contains("Question") || text.contains("Answer") || text.contains("Definition"));
}