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

//! Inline unit tests for [`CoreError`] construction and property accessors.

use super::*;
#[cfg(not(feature = "std"))]
use alloc::{format, string::ToString};

#[test]
fn error_creation_methods() {
    let parse_err = CoreError::parse("test message");
    assert!(matches!(parse_err, CoreError::Parse(_)));

    let color_err = CoreError::invalid_color("invalid");
    assert!(matches!(color_err, CoreError::InvalidColor(_)));

    let time_err = CoreError::invalid_time("invalid", "wrong format");
    assert!(matches!(time_err, CoreError::InvalidTime(_)));
}

#[test]
fn error_display() {
    let error = CoreError::invalid_color("test");
    let display_str = format!("{error}");
    assert!(display_str.contains("Invalid color format"));
    assert!(display_str.contains("test"));
}

#[test]
fn error_properties() {
    let error = CoreError::invalid_color("test");
    assert_eq!(error.category(), ErrorCategory::Format);
    assert!(error.suggestion().is_some());
    assert!(error.is_recoverable());
    assert!(!error.is_internal_bug());
}

#[test]
fn result_type_alias() {
    fn test_function() -> i32 {
        42
    }

    assert_eq!(test_function(), 42);
}

#[test]
fn core_error_invalid_color_convenience() {
    let color_err = CoreError::invalid_color("red");
    assert!(matches!(color_err, CoreError::InvalidColor(_)));
    if let CoreError::InvalidColor(msg) = color_err {
        assert!(msg.contains("red"));
    }
}

#[test]
fn core_error_invalid_numeric_convenience() {
    let numeric_err = CoreError::invalid_numeric("abc", "not a number");
    assert!(matches!(numeric_err, CoreError::InvalidNumeric(_)));
    if let CoreError::InvalidNumeric(msg) = numeric_err {
        assert!(msg.contains("abc"));
        assert!(msg.contains("not a number"));
    }
}

#[test]
fn core_error_invalid_time_convenience() {
    let time_err = CoreError::invalid_time("25:00:00", "hours out of range");
    assert!(matches!(time_err, CoreError::InvalidTime(_)));
    if let CoreError::InvalidTime(msg) = time_err {
        assert!(msg.contains("25:00:00"));
        assert!(msg.contains("hours out of range"));
    }
}

#[test]
fn core_error_utf8_error_convenience() {
    let utf8_err = CoreError::utf8_error(42, "invalid sequence".to_string());
    assert!(matches!(utf8_err, CoreError::Utf8Error { .. }));
    if let CoreError::Utf8Error { position, message } = utf8_err {
        assert_eq!(position, 42);
        assert_eq!(message, "invalid sequence");
    }
}

#[test]
fn core_error_feature_not_supported_convenience() {
    let feature_err = CoreError::feature_not_supported("simd", "cpu-features");
    assert!(matches!(feature_err, CoreError::FeatureNotSupported { .. }));
    if let CoreError::FeatureNotSupported {
        feature,
        required_feature,
    } = feature_err
    {
        assert_eq!(feature, "simd");
        assert_eq!(required_feature, "cpu-features");
    }
}

#[test]
fn core_error_resource_limit_exceeded_convenience() {
    let resource_err = CoreError::resource_limit_exceeded("memory", 1024, 512);
    assert!(matches!(
        resource_err,
        CoreError::ResourceLimitExceeded { .. }
    ));
    if let CoreError::ResourceLimitExceeded {
        resource,
        current,
        limit,
    } = resource_err
    {
        assert_eq!(resource, "memory");
        assert_eq!(current, 1024);
        assert_eq!(limit, 512);
    }
}