multitude 0.5.1

Fast and flexible arena allocator.
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

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! Tests for the optional serde Serialize impls (gated on the
//! `serde` feature).
//!
//! Multitude provides Serialize but not Deserialize — deserializing into
//! arena-backed types requires an arena context that serde's stock
//! Deserialize trait cannot carry. These tests verify only Serialize
//! round-trips.

#![cfg(feature = "serde")]
#![allow(clippy::std_instead_of_core, reason = "tests use std")]
#![allow(clippy::unwrap_used, reason = "test code")]

mod common;

use multitude::Arena;

#[test]
fn arena_arc_str_serializes_to_string() {
    let arena = Arena::new();
    let s = arena.alloc_str_arc("shared");
    let json = serde_json::to_string(&s).unwrap();
    assert_eq!(json, "\"shared\"");
}

#[test]
fn arena_string_serializes_to_string() {
    let arena = Arena::new();
    let mut s = arena.alloc_string();
    s.push_str("growable");
    let json = serde_json::to_string(&s).unwrap();
    assert_eq!(json, "\"growable\"");
}

#[test]
fn arena_string_empty_serializes() {
    let arena = Arena::new();
    let s = arena.alloc_string();
    let json = serde_json::to_string(&s).unwrap();
    assert_eq!(json, "\"\"");
}

#[test]
fn arena_vec_serializes_to_array() {
    let arena = Arena::new();
    let mut v = arena.alloc_vec::<u32>();
    v.push(1);
    v.push(2);
    v.push(3);
    let json = serde_json::to_string(&v).unwrap();
    assert_eq!(json, "[1,2,3]");
}

#[test]
fn arena_vec_empty_serializes_to_array() {
    let arena = Arena::new();
    let v: multitude::vec::Vec<u32, _> = arena.alloc_vec();
    let json = serde_json::to_string(&v).unwrap();
    assert_eq!(json, "[]");
}

#[test]
fn arena_vec_of_strings_serializes() {
    let arena = Arena::new();
    let mut v = arena.alloc_vec::<String>();
    v.push("a".to_string());
    v.push("b".to_string());
    let json = serde_json::to_string(&v).unwrap();
    assert_eq!(json, "[\"a\",\"b\"]");
}

mod from_coverage_extras_serde {
    #![allow(clippy::items_after_statements, reason = "relocated tests put inner types near use")]
    #![allow(clippy::clone_on_ref_ptr, reason = "relocated tests use .clone() on Arc/Rc")]
    #![allow(dead_code, reason = "relocated helpers retain fields for layout")]
    #![allow(
        unfulfilled_lint_expectations,
        reason = "relocated #[expect] may be fulfilled at file or feature level"
    )]
    #![allow(
        clippy::undocumented_unsafe_blocks,
        reason = "relocated test bodies preserve original safety reasoning"
    )]
    #![allow(clippy::multiple_unsafe_ops_per_block, reason = "relocated tests group related unsafe ops")]
    #![allow(clippy::cast_possible_truncation, reason = "relocated tests use bounded values")]
    #![allow(clippy::cast_sign_loss, reason = "relocated tests use non-negative values")]
    #![allow(clippy::empty_drop, reason = "relocated tests use empty Drop impls to mark dropability")]
    #![allow(clippy::assertions_on_result_states, reason = "relocated tests deliberately assert error returns")]
    #![allow(clippy::empty_line_after_doc_comments, reason = "relocated test doc-comments")]
    use multitude::Arena;

    #[expect(unused_imports, reason = "relocated tests may reference common helpers")]
    use crate::common;

    #[test]
    fn arena_box_str_serializes_to_string() {
        let arena: Arena = Arena::new();
        let s = arena.alloc_str_box("box-str");
        let json = serde_json::to_string(&s).unwrap();
        assert_eq!(json, "\"box-str\"");
    }
}