dfajit 0.1.1

JIT compilation of DFA transition tables to native x86_64 jump tables
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

#![allow(clippy::unwrap_used, clippy::panic)]

use dfajit::{JitDfa, TransitionTable};
use matchkit::Match;

#[test]
fn test_massive_dimensions_fail_safely() {
    // TransitionTable::new should reject dimensions that overflow or exceed limits.
    let res = TransitionTable::new(10_000_000_000, 10_000_000_000);
    assert!(
        res.is_err(),
        "TransitionTable::new should reject oversized tables without crashing"
    );
}

#[test]
fn test_transition_out_of_bounds() {
    let mut table = TransitionTable::new(2, 256).unwrap();
    table.set_transition(0, b'x', 1);

    // Maliciously patch a target to be way out of bounds
    table.transitions_mut()[0] = 5000;

    let res = JitDfa::compile(&table);
    assert!(res.is_err());
    assert!(res.unwrap_err().to_string().contains("exceeds state count"));
}

#[test]
fn test_accept_state_out_of_bounds() {
    let mut table = TransitionTable::new(2, 256).unwrap();
    table.add_accept(5000, 0); // State doesn't exist

    let res = JitDfa::compile(&table);
    assert!(res.is_err());
    assert!(res.unwrap_err().to_string().contains("exceeds state count"));
}

#[test]
fn test_accept_pattern_out_of_bounds() {
    let mut table = TransitionTable::new(2, 256).unwrap();
    // Add accept but don't specify pattern length for the pattern ID
    table.accept_states_mut().push((1, 9999));

    let res = JitDfa::compile(&table);
    assert!(res.is_err());
    assert!(res
        .unwrap_err()
        .to_string()
        .contains("has no length defined"));
}

#[test]
fn test_scan_zero_length_input() {
    let table = TransitionTable::new(2, 256).unwrap();
    let jit = JitDfa::compile(&table).unwrap();

    let mut matches = vec![Match::from_parts(0, 0, 0); 10];
    let count = jit.scan(&[], &mut matches);
    assert_eq!(count, 0);
}

#[test]
fn test_scan_gigantic_buffer_size() {
    let mut table = TransitionTable::new(2, 256).unwrap();
    table.set_transition(0, b'a', 1);
    table.add_accept(1, 0);
    table.set_pattern_length(0, 1);

    let jit = JitDfa::compile(&table).unwrap();

    // Use a large zero buffer (cheap memory wise compared to alloc)
    // We expect 0 matches since our pattern is 'a'
    let huge_input = vec![0u8; 10_000_000];
    let mut matches = vec![Match::from_parts(0, 0, 0); 1];

    let count = jit.scan(&huge_input, &mut matches);
    assert_eq!(count, 0);
}

#[test]
fn test_scan_near_usize_max_matches_buffer() {
    let mut table = TransitionTable::new(2, 256).unwrap();
    table.set_transition(0, b'a', 1);
    table.add_accept(1, 0);
    table.set_pattern_length(0, 1);
    let jit = JitDfa::compile(&table).unwrap();

    // With the new semantics, if we pass an empty buffer, scan returns 0
    // because it caps at buffer size. scan_count returns the true count.
    let count = jit.scan_count(b"a");
    assert_eq!(count, 1);

    // Testing scan with an empty buffer should return 0 safely without crashing.
    let scanned = jit.scan(b"a", &mut []);
    assert_eq!(scanned, 0);
}

#[test]
fn test_multiple_accepts_same_state() {
    let mut table = TransitionTable::new(2, 256).unwrap();
    table.add_accept(1, 0);
    table.add_accept(1, 1);
    table.set_pattern_length(0, 1);
    table.set_pattern_length(1, 1);

    let res = JitDfa::compile(&table);
    assert!(res.is_err());
    assert!(res
        .unwrap_err()
        .to_string()
        .contains("multiple accept patterns"));
}