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
141
142
143
144
145
146
147
148

//! Targeted token-kind coverage tests for [`AssTokenizer`].

use super::*;

#[test]
fn tokenizer_context_based_token_creation() {
    let source = "{\\b1}Bold text{\\b0}";
    let mut tokenizer = AssTokenizer::new(source);

    let mut token_count = 0;
    while let Ok(Some(token)) = tokenizer.next_token() {
        // Verify each token was created with proper context
        assert!(token.line >= 1);
        assert!(token.column >= 1);
        assert!(!token.span.is_empty());

        token_count += 1;
        if token_count > 15 {
            break;
        }
    }

    assert!(token_count > 0);
}

#[test]
fn tokenizer_section_header_start_tracking() {
    // Target lines 93-95: start position tracking
    let source = "[Script Info]";
    let mut tokenizer = AssTokenizer::new(source);

    // This should hit the start_pos, start_line, start_column tracking
    let token = tokenizer.next_token().unwrap().unwrap();
    assert_eq!(token.line, 1);
    assert_eq!(token.column, 1);
}

#[test]
fn tokenizer_section_close_bracket() {
    // Target lines 104-106: ']' in SectionHeader context
    let source = "[Test]";
    let mut tokenizer = AssTokenizer::new(source);

    // Get section header
    let _header = tokenizer.next_token().unwrap().unwrap();
    // Get closing bracket - this should hit lines 104-106
    let close = tokenizer.next_token().unwrap().unwrap();
    assert_eq!(
        close.token_type,
        crate::tokenizer::tokens::TokenType::SectionClose
    );
}

#[test]
fn tokenizer_colon_field_separator() {
    // Target lines 109: ':' in Document context
    let source = "Key:Value";
    let mut tokenizer = AssTokenizer::new(source);

    // Get key
    let _key = tokenizer.next_token().unwrap().unwrap();
    // Get colon - this should hit line 109
    let colon = tokenizer.next_token().unwrap().unwrap();
    assert_eq!(colon.token_type, crate::tokenizer::tokens::TokenType::Colon);
}

#[test]
fn tokenizer_comma_separator() {
    // Target lines 115: ',' token
    let source = "val1,val2";
    let mut tokenizer = AssTokenizer::new(source);

    let _val1 = tokenizer.next_token().unwrap().unwrap();
    let comma = tokenizer.next_token().unwrap().unwrap();
    assert_eq!(comma.token_type, crate::tokenizer::tokens::TokenType::Comma);
}

#[test]
fn tokenizer_newline_handling() {
    // Target lines 119, 121: newline tokens
    let source = "line1\nline2\r\nline3";
    let mut tokenizer = AssTokenizer::new(source);

    let _line1 = tokenizer.next_token().unwrap().unwrap();
    let newline1 = tokenizer.next_token().unwrap().unwrap();
    assert_eq!(
        newline1.token_type,
        crate::tokenizer::tokens::TokenType::Newline
    );
}

#[test]
fn tokenizer_style_override_tokens() {
    // Target lines 124, 128: '{' and '}' tokens
    let source = "{\\b1}text{\\b0}";
    let mut tokenizer = AssTokenizer::new(source);

    let override_block = tokenizer.next_token().unwrap().unwrap();
    assert_eq!(
        override_block.token_type,
        crate::tokenizer::tokens::TokenType::OverrideBlock
    );
}

#[test]
fn tokenizer_comment_exclamation() {
    // Target lines 137: '!' comment
    let source = "!: This is a comment";
    let mut tokenizer = AssTokenizer::new(source);

    let comment = tokenizer.next_token().unwrap().unwrap();
    assert_eq!(
        comment.token_type,
        crate::tokenizer::tokens::TokenType::Comment
    );
}

#[test]
fn tokenizer_comment_semicolon() {
    // Target lines 146: ';' comment
    let source = "; This is a comment";
    let mut tokenizer = AssTokenizer::new(source);

    let comment = tokenizer.next_token().unwrap().unwrap();
    assert_eq!(
        comment.token_type,
        crate::tokenizer::tokens::TokenType::Comment
    );
}

#[test]
fn tokenizer_whitespace_token() {
    // Target lines 151: whitespace handling
    // Use FieldValue context where whitespace isn't skipped
    let source = "Key:   \t  ";
    let mut tokenizer = AssTokenizer::new(source);

    // Get key token
    let _key = tokenizer.next_token().unwrap().unwrap();
    // Get colon token (switches to FieldValue context)
    let _colon = tokenizer.next_token().unwrap().unwrap();
    // Get whitespace token in FieldValue context
    let whitespace = tokenizer.next_token().unwrap().unwrap();
    assert_eq!(
        whitespace.token_type,
        crate::tokenizer::tokens::TokenType::Whitespace
    );
}