plotnik-compiler 0.3.2

Compiler for Plotnik query language (parser, analyzer, bytecode emitter)
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

//! Unit tests for StringTableBuilder.

use plotnik_core::Interner;

use super::string_table::{EASTER_EGG, StringTableBuilder};

#[test]
fn new_builder_has_easter_egg_at_index_zero() {
    let builder = StringTableBuilder::new();

    assert_eq!(builder.len(), 1);
    assert!(!builder.is_empty());

    let (blob, _) = builder.emit();
    assert_eq!(std::str::from_utf8(&blob).unwrap(), EASTER_EGG);
}

#[test]
fn intern_symbol_twice_returns_same_id() {
    let mut interner = Interner::new();
    let sym = interner.intern("hello");

    let mut builder = StringTableBuilder::new();

    let id1 = builder.get_or_intern(sym, &interner).unwrap();
    let id2 = builder.get_or_intern(sym, &interner).unwrap();

    assert_eq!(id1, id2);
    assert_eq!(builder.len(), 2); // easter egg + "hello"
}

#[test]
fn intern_different_symbols_returns_different_ids() {
    let mut interner = Interner::new();
    let sym1 = interner.intern("hello");
    let sym2 = interner.intern("world");

    let mut builder = StringTableBuilder::new();

    let id1 = builder.get_or_intern(sym1, &interner).unwrap();
    let id2 = builder.get_or_intern(sym2, &interner).unwrap();

    assert_ne!(id1, id2);
    assert_eq!(builder.len(), 3); // easter egg + "hello" + "world"
}

#[test]
fn intern_str_deduplicates() {
    let mut builder = StringTableBuilder::new();

    let id1 = builder.intern_str("test");
    let id2 = builder.intern_str("test");
    let id3 = builder.intern_str("other");

    assert_eq!(id1, id2);
    assert_ne!(id1, id3);
    assert_eq!(builder.len(), 3); // easter egg + "test" + "other"
}

#[test]
fn get_returns_none_for_unknown_symbol() {
    let mut interner = Interner::new();
    let known = interner.intern("known");
    let unknown = interner.intern("unknown");

    let mut builder = StringTableBuilder::new();
    builder.get_or_intern(known, &interner).unwrap();

    assert!(builder.get(known).is_some());
    assert!(builder.get(unknown).is_none());
}

#[test]
fn validate_passes_for_normal_counts() {
    let builder = StringTableBuilder::new();

    assert!(builder.validate().is_ok());
}

#[test]
fn emit_produces_correct_format() {
    let mut builder = StringTableBuilder::new();
    builder.intern_str("abc");
    builder.intern_str("defgh");

    let (blob, table) = builder.emit();

    // Blob should contain: EASTER_EGG + "abc" + "defgh"
    let expected_blob = format!("{EASTER_EGG}abcdefgh");
    assert_eq!(blob, expected_blob.as_bytes());

    // Table should have 4 entries (3 strings + sentinel)
    // Each entry is 4 bytes (u32 le)
    assert_eq!(table.len(), 4 * 4);

    // Verify offsets
    let offsets: Vec<u32> = table
        .chunks(4)
        .map(|chunk| u32::from_le_bytes(chunk.try_into().unwrap()))
        .collect();

    assert_eq!(offsets[0], 0); // EASTER_EGG starts at 0
    assert_eq!(offsets[1], EASTER_EGG.len() as u32); // "abc" starts after easter egg
    assert_eq!(offsets[2], (EASTER_EGG.len() + 3) as u32); // "defgh" starts after "abc"
    assert_eq!(offsets[3], (EASTER_EGG.len() + 8) as u32); // sentinel
}

#[test]
fn string_not_found_error_for_unknown_symbol() {
    let mut interner = Interner::new();
    let sym = interner.intern("exists");

    // Create a different interner without the symbol
    let other_interner = Interner::new();

    let mut builder = StringTableBuilder::new();
    let result = builder.get_or_intern(sym, &other_interner);

    assert!(result.is_err());
}