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

//! Behavioural tests for the [`ParseDelta`] enum.

use super::*;
use crate::parser::ast::{ScriptInfo, Section, Span};
#[cfg(not(feature = "std"))]
use alloc::{format, string::ToString, vec};

#[test]
fn delta_creation() {
    let section = Section::ScriptInfo(ScriptInfo {
        fields: vec![],
        span: Span::new(0, 0, 0, 0),
    });
    let delta = ParseDelta::add_section(section);
    assert!(matches!(delta, ParseDelta::AddSection(_)));
    assert!(!delta.is_error());
    assert!(delta.is_structural());
}

#[test]
fn delta_properties() {
    let remove_delta = ParseDelta::remove_section(5);
    assert!(remove_delta.is_structural());
    assert!(!remove_delta.is_error());
    assert_eq!(remove_delta.section(), None);

    let error_delta = ParseDelta::parse_issue("Test error".to_string());
    assert!(!error_delta.is_structural());
    assert!(error_delta.is_error());
}

#[test]
fn delta_update_section() {
    let section = Section::ScriptInfo(ScriptInfo {
        fields: vec![],
        span: Span::new(0, 0, 0, 0),
    });
    let delta = ParseDelta::update_section(3, section);

    assert!(matches!(delta, ParseDelta::UpdateSection(3, _)));
    assert!(!delta.is_error());
    assert!(delta.is_structural());
    assert!(delta.section().is_some());
}

#[test]
fn delta_section_getter() {
    let section = Section::ScriptInfo(ScriptInfo {
        fields: vec![],
        span: Span::new(0, 0, 0, 0),
    });

    let add_delta = ParseDelta::add_section(section.clone());
    assert!(add_delta.section().is_some());

    let update_delta = ParseDelta::update_section(0, section);
    assert!(update_delta.section().is_some());

    let remove_delta = ParseDelta::remove_section(1);
    assert!(remove_delta.section().is_none());

    let error_delta = ParseDelta::parse_issue("Test".to_string());
    assert!(error_delta.section().is_none());
}

#[test]
fn delta_debug_formatting() {
    let section = Section::ScriptInfo(ScriptInfo {
        fields: vec![],
        span: Span::new(0, 0, 0, 0),
    });
    let delta = ParseDelta::add_section(section);
    let debug_str = format!("{delta:?}");
    assert!(debug_str.contains("AddSection"));

    let error_delta = ParseDelta::parse_issue("Error message".to_string());
    let error_debug = format!("{error_delta:?}");
    assert!(error_debug.contains("ParseIssue"));
    assert!(error_debug.contains("Error message"));
}

#[test]
fn delta_clone() {
    let section = Section::ScriptInfo(ScriptInfo {
        fields: vec![],
        span: Span::new(0, 0, 0, 0),
    });
    let delta = ParseDelta::add_section(section);
    let cloned = delta.clone();

    assert!(matches!(cloned, ParseDelta::AddSection(_)));
    assert_eq!(delta.is_error(), cloned.is_error());
    assert_eq!(delta.is_structural(), cloned.is_structural());
}

#[test]
fn delta_all_constructors() {
    let section = Section::ScriptInfo(ScriptInfo {
        fields: vec![],
        span: Span::new(0, 0, 0, 0),
    });

    let add = ParseDelta::add_section(section.clone());
    assert!(matches!(add, ParseDelta::AddSection(_)));

    let update = ParseDelta::update_section(42, section);
    assert!(matches!(update, ParseDelta::UpdateSection(42, _)));

    let remove = ParseDelta::remove_section(99);
    assert!(matches!(remove, ParseDelta::RemoveSection(99)));

    let issue = ParseDelta::parse_issue("Test issue".to_string());
    assert!(matches!(issue, ParseDelta::ParseIssue(_)));
}

#[test]
fn delta_all_variants_coverage() {
    // Test all ParseDelta variants
    let section = Section::ScriptInfo(ScriptInfo {
        fields: vec![],
        span: Span::new(0, 0, 0, 0),
    });

    // AddSection
    let add = ParseDelta::AddSection(section.clone());
    assert!(add.is_structural());
    assert!(!add.is_error());
    assert!(add.section().is_some());

    // UpdateSection
    let update = ParseDelta::UpdateSection(5, section);
    assert!(update.is_structural());
    assert!(!update.is_error());
    assert!(update.section().is_some());

    // RemoveSection
    let remove = ParseDelta::RemoveSection(10);
    assert!(remove.is_structural());
    assert!(!remove.is_error());
    assert!(remove.section().is_none());

    // ParseIssue
    let issue = ParseDelta::ParseIssue("Critical error".to_string());
    assert!(!issue.is_structural());
    assert!(issue.is_error());
    assert!(issue.section().is_none());
}