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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Tests for parser construction and basic section parsing.

use super::*;

fn create_test_script(content: &str) -> String {
    format!("[Script Info]\nTitle: Test\n\n{content}")
}

#[test]
fn parser_new() {
    let source = "test content";
    let parser = Parser::new(source);
    assert_eq!(parser.source, source);
    assert_eq!(parser.position, 0);
    assert_eq!(parser.line, 1);
    assert_eq!(parser.version, ScriptVersion::AssV4);
    assert!(parser.sections.is_empty());
    assert!(parser.issues.is_empty());
    assert!(parser.styles_format.is_none());
    assert!(parser.events_format.is_none());
}

#[test]
fn parser_parse_empty_script() {
    let parser = Parser::new("");
    let script = parser.parse();
    assert_eq!(script.version(), ScriptVersion::AssV4);
    assert!(script.sections().is_empty());
}

#[test]
fn parser_parse_with_bom() {
    let content = "\u{FEFF}[Script Info]\nTitle: Test";
    let parser = Parser::new(content);
    let script = parser.parse();
    assert!(!script.sections().is_empty());
}

#[test]
fn parser_parse_input_size_limit() {
    let large_content = "a".repeat(51 * 1024 * 1024); // 51MB > 50MB limit
    let parser = Parser::new(&large_content);
    let script = parser.parse();
    assert!(!script.issues().is_empty());
    let has_size_error = script
        .issues()
        .iter()
        .any(|issue| issue.message.contains("Input size limit exceeded"));
    assert!(has_size_error);
}

#[test]
fn parser_parse_unknown_section() {
    let content = "[Unknown Section]\nSome content";
    let parser = Parser::new(content);
    let script = parser.parse();
    let has_unknown_section_warning = script
        .issues()
        .iter()
        .any(|issue| issue.message.contains("Unknown section"));
    assert!(has_unknown_section_warning);
}

#[test]
fn parser_parse_unclosed_section_header() {
    let content = "[Script Info\nTitle: Test";
    let parser = Parser::new(content);
    let script = parser.parse();
    let has_unclosed_error = script.issues().iter().any(|issue| {
        issue.message.contains("Unclosed section header")
            || issue.message.contains("Failed to parse section")
    });
    assert!(has_unclosed_error);
}

#[test]
fn parser_parse_missing_section_header() {
    let content = "Title: Test\nAuthor: Someone";
    let parser = Parser::new(content);
    let script = parser.parse();
    let has_header_error = script.issues().iter().any(|issue| {
        issue.message.contains("Expected section header")
            || issue.message.contains("Failed to parse section")
    });
    assert!(has_header_error);
}

#[test]
fn parser_parse_script_info_section() {
    let content = "[Script Info]\nTitle: Test Script\nScriptType: v4.00+";
    let parser = Parser::new(content);
    let script = parser.parse();
    assert_eq!(script.sections().len(), 1);
    // Version should be updated based on ScriptType parsing
    assert!(
        script.version() == ScriptVersion::AssV4Plus || script.version() == ScriptVersion::AssV4
    );
}

#[test]
fn parser_parse_styles_section() {
    let content = create_test_script("[V4+ Styles]\nFormat: Name, Fontname\nStyle: Default,Arial");
    let parser = Parser::new(&content);
    let script = parser.parse();
    assert!(script.sections().len() >= 2);
}

#[test]
fn parser_parse_events_section() {
    let content = create_test_script(
        "[Events]\nFormat: Start, End, Text\nDialogue: 0:00:00.00,0:00:05.00,Test",
    );
    let parser = Parser::new(&content);
    let script = parser.parse();
    assert!(script.sections().len() >= 2);
}

#[test]
fn parser_parse_fonts_section() {
    let content = create_test_script("[Fonts]\nfontname: Arial\nfontdata: ABCD1234");
    let parser = Parser::new(&content);
    let script = parser.parse();
    assert!(script.sections().len() >= 2);
}

#[test]
fn parser_parse_graphics_section() {
    let content = create_test_script("[Graphics]\nfilename: image.png\ndata: ABCD1234");
    let parser = Parser::new(&content);
    let script = parser.parse();
    assert!(script.sections().len() >= 2);
}

#[test]
fn parser_skip_comments() {
    let content = "; This is a comment\n!: Another comment\n[Script Info]\nTitle: Test";
    let parser = Parser::new(content);
    let script = parser.parse();
    assert!(!script.sections().is_empty());
}