radiance · Radiance self-hosting compiler

test/tests/slice.append.rad 4.1 KiB raw

//! returns: 0
//! Test slice .append() method with inline allocator.

/// Simple bump allocator for testing.
record Arena: Copy {
    data: *mut [u8],
    offset: u32,
}

fn newArena(data: *mut [u8]) -> Arena {
    return Arena { data, offset: 0 };
}

fn arenaAlloc(arena: *mut Arena, size: u32, al: u32) -> *mut opaque {
    let aligned = (arena.offset + al - 1) / al * al;
    let newOffset = aligned + size;

    assert newOffset <= arena.data.len as u32;

    let base: *mut u8 = &mut arena.data[aligned];
    set arena.offset = newOffset;

    return base as *mut opaque;
}

/// Allocator record matching the compiler's expected layout.
record Allocator: Copy {
    func: fn(*mut opaque, u32, u32) -> *mut opaque,
    ctx: *mut opaque,
}

fn arenaAllocFn(ctx: *mut opaque, size: u32, al: u32) -> *mut opaque {
    let arena = ctx as *mut Arena;
    return arenaAlloc(arena, size, al);
}

fn arenaAllocator(arena: *mut Arena) -> Allocator {
    return Allocator {
        func: arenaAllocFn,
        ctx: arena as *mut opaque,
    };
}

static BUF: [u8; 4096] = undefined;

@default fn main() -> i32 {
    let mut arena = newArena(&mut BUF[..]);
    let a = arenaAllocator(&mut arena);

    // Allocate initial capacity of 4.
    let ptr = arenaAlloc(&mut arena, @sizeOf(i32) * 4, @alignOf(i32));
    let mut nums = @sliceOf(ptr as *mut i32, 0, 4);

    // Append within capacity.
    nums.append(10, a);
    nums.append(20, a);
    nums.append(30, a);

    if nums.len <> 3 {
        return 1;
    }
    if nums.cap <> 4 {
        return 2;
    }
    if nums[0] <> 10 {
        return 3;
    }
    if nums[1] <> 20 {
        return 4;
    }
    if nums[2] <> 30 {
        return 5;
    }

    // Append to fill capacity.
    nums.append(40, a);

    if nums.len <> 4 {
        return 6;
    }
    if nums.cap <> 4 {
        return 7;
    }

    // Append past capacity -- triggers growth.
    nums.append(50, a);

    if nums.len <> 5 {
        return 8;
    }
    // Cap should have grown (cap * 2 | 1 = 4 * 2 | 1 = 9).
    if nums.cap <> 9 {
        return 9;
    }
    if nums[4] <> 50 {
        return 10;
    }

    // Verify old elements survived the copy.
    if nums[0] <> 10 {
        return 11;
    }
    if nums[3] <> 40 {
        return 12;
    }

    // Append from empty (cap == 0 triggers growth with cap = 1).
    let mut empty = @sliceOf(ptr as *mut i32, 0, 0);
    empty.append(99, a);

    if empty.len <> 1 {
        return 13;
    }
    if empty.cap <> 1 {
        return 14;
    }
    if empty[0] <> 99 {
        return 15;
    }

    // Sum all elements in nums.
    let mut sum: i32 = 0;
    for n in nums {
        set sum += n;
    }
    if sum <> 150 {
        return 16;
    }

    // Test append with u8 elements (stride = 1).
    let bytePtr = arenaAlloc(&mut arena, 2, 1);
    let mut bytes = @sliceOf(bytePtr as *mut u8, 0, 2);
    bytes.append(0xAB, a);
    bytes.append(0xCD, a);

    if bytes.len <> 2 {
        return 17;
    }
    if bytes[0] <> 0xAB {
        return 18;
    }
    if bytes[1] <> 0xCD {
        return 19;
    }

    // Trigger growth on u8 slice.
    bytes.append(0xEF, a);

    if bytes.len <> 3 {
        return 20;
    }
    if bytes.cap <> 5 {
        return 21;
    }
    if bytes[2] <> 0xEF {
        return 22;
    }
    // Verify old u8 elements survived.
    if bytes[0] <> 0xAB {
        return 23;
    }

    // Test that .append() returns the slice, allowing rebinding.
    let ptr2 = arenaAlloc(&mut arena, @sizeOf(i32) * 2, @alignOf(i32));
    let mut vals = @sliceOf(ptr2 as *mut i32, 0, 2);

    // Append within capacity, rebind via return value.
    set vals = vals.append(42, a);
    assert vals.len == 1;
    assert vals[0] == 42;

    set vals = vals.append(43, a);
    assert vals.len == 2;

    // Append past capacity -- triggers growth and returns updated slice.
    let oldPtr = &vals[0] as *opaque;
    set vals = vals.append(44, a);
    assert vals.len == 3;
    assert vals.cap == 5;

    // After growth, the data pointer should have changed.
    let newPtr = &vals[0] as *opaque;
    assert oldPtr <> newPtr;

    // Verify all elements survived.
    assert vals[0] == 42;
    assert vals[1] == 43;
    assert vals[2] == 44;

    return 0;
}

1	//! returns: 0
2	//! Test slice .append() method with inline allocator.
3
4	/// Simple bump allocator for testing.
5	record Arena: Copy {
6	data: *mut [u8],
7	offset: u32,
8	}
9
10	fn newArena(data: *mut [u8]) -> Arena {
11	return Arena { data, offset: 0 };
12	}
13
14	fn arenaAlloc(arena: mut Arena, size: u32, al: u32) -> mut opaque {
15	let aligned = (arena.offset + al - 1) / al * al;
16	let newOffset = aligned + size;
17
18	assert newOffset <= arena.data.len as u32;
19
20	let base: *mut u8 = &mut arena.data[aligned];
21	set arena.offset = newOffset;
22
23	return base as *mut opaque;
24	}
25
26	/// Allocator record matching the compiler's expected layout.
27	record Allocator: Copy {
28	func: fn(mut opaque, u32, u32) -> mut opaque,
29	ctx: *mut opaque,
30	}
31
32	fn arenaAllocFn(ctx: mut opaque, size: u32, al: u32) -> mut opaque {
33	let arena = ctx as *mut Arena;
34	return arenaAlloc(arena, size, al);
35	}
36
37	fn arenaAllocator(arena: *mut Arena) -> Allocator {
38	return Allocator {
39	func: arenaAllocFn,
40	ctx: arena as *mut opaque,
41	};
42	}
43
44	static BUF: [u8; 4096] = undefined;
45
46	@default fn main() -> i32 {
47	let mut arena = newArena(&mut BUF[..]);
48	let a = arenaAllocator(&mut arena);
49
50	// Allocate initial capacity of 4.
51	let ptr = arenaAlloc(&mut arena, @sizeOf(i32) * 4, @alignOf(i32));
52	let mut nums = @sliceOf(ptr as *mut i32, 0, 4);
53
54	// Append within capacity.
55	nums.append(10, a);
56	nums.append(20, a);
57	nums.append(30, a);
58
59	if nums.len <> 3 {
60	return 1;
61	}
62	if nums.cap <> 4 {
63	return 2;
64	}
65	if nums[0] <> 10 {
66	return 3;
67	}
68	if nums[1] <> 20 {
69	return 4;
70	}
71	if nums[2] <> 30 {
72	return 5;
73	}
74
75	// Append to fill capacity.
76	nums.append(40, a);
77
78	if nums.len <> 4 {
79	return 6;
80	}
81	if nums.cap <> 4 {
82	return 7;
83	}
84
85	// Append past capacity -- triggers growth.
86	nums.append(50, a);
87
88	if nums.len <> 5 {
89	return 8;
90	}
91	// Cap should have grown (cap * 2 \| 1 = 4 * 2 \| 1 = 9).
92	if nums.cap <> 9 {
93	return 9;
94	}
95	if nums[4] <> 50 {
96	return 10;
97	}
98
99	// Verify old elements survived the copy.
100	if nums[0] <> 10 {
101	return 11;
102	}
103	if nums[3] <> 40 {
104	return 12;
105	}
106
107	// Append from empty (cap == 0 triggers growth with cap = 1).
108	let mut empty = @sliceOf(ptr as *mut i32, 0, 0);
109	empty.append(99, a);
110
111	if empty.len <> 1 {
112	return 13;
113	}
114	if empty.cap <> 1 {
115	return 14;
116	}
117	if empty[0] <> 99 {
118	return 15;
119	}
120
121	// Sum all elements in nums.
122	let mut sum: i32 = 0;
123	for n in nums {
124	set sum += n;
125	}
126	if sum <> 150 {
127	return 16;
128	}
129
130	// Test append with u8 elements (stride = 1).
131	let bytePtr = arenaAlloc(&mut arena, 2, 1);
132	let mut bytes = @sliceOf(bytePtr as *mut u8, 0, 2);
133	bytes.append(0xAB, a);
134	bytes.append(0xCD, a);
135
136	if bytes.len <> 2 {
137	return 17;
138	}
139	if bytes[0] <> 0xAB {
140	return 18;
141	}
142	if bytes[1] <> 0xCD {
143	return 19;
144	}
145
146	// Trigger growth on u8 slice.
147	bytes.append(0xEF, a);
148
149	if bytes.len <> 3 {
150	return 20;
151	}
152	if bytes.cap <> 5 {
153	return 21;
154	}
155	if bytes[2] <> 0xEF {
156	return 22;
157	}
158	// Verify old u8 elements survived.
159	if bytes[0] <> 0xAB {
160	return 23;
161	}
162
163	// Test that .append() returns the slice, allowing rebinding.
164	let ptr2 = arenaAlloc(&mut arena, @sizeOf(i32) * 2, @alignOf(i32));
165	let mut vals = @sliceOf(ptr2 as *mut i32, 0, 2);
166
167	// Append within capacity, rebind via return value.
168	set vals = vals.append(42, a);
169	assert vals.len == 1;
170	assert vals[0] == 42;
171
172	set vals = vals.append(43, a);
173	assert vals.len == 2;
174
175	// Append past capacity -- triggers growth and returns updated slice.
176	let oldPtr = &vals[0] as *opaque;
177	set vals = vals.append(44, a);
178	assert vals.len == 3;
179	assert vals.cap == 5;
180
181	// After growth, the data pointer should have changed.
182	let newPtr = &vals[0] as *opaque;
183	assert oldPtr <> newPtr;
184
185	// Verify all elements survived.
186	assert vals[0] == 42;
187	assert vals[1] == 43;
188	assert vals[2] == 44;
189
190	return 0;
191	}