Move debug.global_allocator to testing.allocator
parent
34706dad3f
commit
4d134a01f5
|
@ -672,7 +672,7 @@ const TermState = enum {
|
|||
|
||||
test "term color" {
|
||||
const input_bytes = "A\x1b[32;1mgreen\x1b[0mB";
|
||||
const result = try termColor(std.debug.global_allocator, input_bytes);
|
||||
const result = try termColor(std.testing.allocator, input_bytes);
|
||||
testing.expectEqualSlices(u8, "A<span class=\"t32\">green</span>B", result);
|
||||
}
|
||||
|
||||
|
|
|
@ -320,7 +320,7 @@ test "std.ArrayList.basic" {
|
|||
}
|
||||
|
||||
test "std.ArrayList.orderedRemove" {
|
||||
var list = ArrayList(i32).init(debug.global_allocator);
|
||||
var list = ArrayList(i32).init(testing.allocator);
|
||||
defer list.deinit();
|
||||
|
||||
try list.append(1);
|
||||
|
@ -347,7 +347,7 @@ test "std.ArrayList.orderedRemove" {
|
|||
}
|
||||
|
||||
test "std.ArrayList.swapRemove" {
|
||||
var list = ArrayList(i32).init(debug.global_allocator);
|
||||
var list = ArrayList(i32).init(testing.allocator);
|
||||
defer list.deinit();
|
||||
|
||||
try list.append(1);
|
||||
|
@ -374,7 +374,7 @@ test "std.ArrayList.swapRemove" {
|
|||
}
|
||||
|
||||
test "std.ArrayList.swapRemoveOrError" {
|
||||
var list = ArrayList(i32).init(debug.global_allocator);
|
||||
var list = ArrayList(i32).init(testing.allocator);
|
||||
defer list.deinit();
|
||||
|
||||
// Test just after initialization
|
||||
|
@ -402,7 +402,7 @@ test "std.ArrayList.swapRemoveOrError" {
|
|||
}
|
||||
|
||||
test "std.ArrayList.insert" {
|
||||
var list = ArrayList(i32).init(debug.global_allocator);
|
||||
var list = ArrayList(i32).init(testing.allocator);
|
||||
defer list.deinit();
|
||||
|
||||
try list.append(1);
|
||||
|
@ -416,7 +416,7 @@ test "std.ArrayList.insert" {
|
|||
}
|
||||
|
||||
test "std.ArrayList.insertSlice" {
|
||||
var list = ArrayList(i32).init(debug.global_allocator);
|
||||
var list = ArrayList(i32).init(testing.allocator);
|
||||
defer list.deinit();
|
||||
|
||||
try list.append(1);
|
||||
|
@ -443,7 +443,7 @@ const Item = struct {
|
|||
};
|
||||
|
||||
test "std.ArrayList: ArrayList(T) of struct T" {
|
||||
var root = Item{ .integer = 1, .sub_items = ArrayList(Item).init(debug.global_allocator) };
|
||||
try root.sub_items.append(Item{ .integer = 42, .sub_items = ArrayList(Item).init(debug.global_allocator) });
|
||||
var root = Item{ .integer = 1, .sub_items = ArrayList(Item).init(testing.allocator) };
|
||||
try root.sub_items.append(Item{ .integer = 42, .sub_items = ArrayList(Item).init(testing.allocator) });
|
||||
testing.expect(root.sub_items.items[0].integer == 42);
|
||||
}
|
||||
|
|
|
@ -150,7 +150,7 @@ pub const Buffer = struct {
|
|||
};
|
||||
|
||||
test "simple Buffer" {
|
||||
var buf = try Buffer.init(debug.global_allocator, "");
|
||||
var buf = try Buffer.init(testing.allocator, "");
|
||||
testing.expect(buf.len() == 0);
|
||||
try buf.append("hello");
|
||||
try buf.append(" ");
|
||||
|
@ -169,14 +169,14 @@ test "simple Buffer" {
|
|||
}
|
||||
|
||||
test "Buffer.initSize" {
|
||||
var buf = try Buffer.initSize(debug.global_allocator, 3);
|
||||
var buf = try Buffer.initSize(testing.allocator, 3);
|
||||
testing.expect(buf.len() == 3);
|
||||
try buf.append("hello");
|
||||
testing.expect(mem.eql(u8, buf.toSliceConst()[3..], "hello"));
|
||||
}
|
||||
|
||||
test "Buffer.initCapacity" {
|
||||
var buf = try Buffer.initCapacity(debug.global_allocator, 10);
|
||||
var buf = try Buffer.initCapacity(testing.allocator, 10);
|
||||
testing.expect(buf.len() == 0);
|
||||
testing.expect(buf.capacity() >= 10);
|
||||
const old_cap = buf.capacity();
|
||||
|
|
|
@ -20,7 +20,7 @@ const windows = std.os.windows;
|
|||
pub const leb = @import("debug/leb128.zig");
|
||||
|
||||
pub const FailingAllocator = @import("debug/failing_allocator.zig").FailingAllocator;
|
||||
pub const failing_allocator = &FailingAllocator.init(global_allocator, 0).allocator;
|
||||
pub const failing_allocator = &FailingAllocator.init(&global_fixed_allocator.allocator, 0).allocator;
|
||||
|
||||
pub const runtime_safety = switch (builtin.mode) {
|
||||
.Debug, .ReleaseSafe => true,
|
||||
|
@ -2192,8 +2192,9 @@ fn readInitialLength(comptime E: type, in_stream: *io.InStream(E), is_64: *bool)
|
|||
}
|
||||
}
|
||||
|
||||
/// This should only be used in temporary test programs.
|
||||
pub const global_allocator = &global_fixed_allocator.allocator;
|
||||
pub const global_allocator = blk: {
|
||||
@compileError("Please switch to std.testing.allocator.");
|
||||
};
|
||||
var global_fixed_allocator = std.heap.ThreadSafeFixedBufferAllocator.init(global_allocator_mem[0..]);
|
||||
var global_allocator_mem: [100 * 1024]u8 = undefined;
|
||||
|
||||
|
|
|
@ -347,7 +347,7 @@ pub fn LinearFifo(
|
|||
}
|
||||
|
||||
test "LinearFifo(u8, .Dynamic)" {
|
||||
var fifo = LinearFifo(u8, .Dynamic).init(debug.global_allocator);
|
||||
var fifo = LinearFifo(u8, .Dynamic).init(testing.allocator);
|
||||
defer fifo.deinit();
|
||||
|
||||
try fifo.write("HELLO");
|
||||
|
@ -422,7 +422,7 @@ test "LinearFifo" {
|
|||
var fifo = switch (bt) {
|
||||
.Static => FifoType.init(),
|
||||
.Slice => FifoType.init(buf[0..]),
|
||||
.Dynamic => FifoType.init(debug.global_allocator),
|
||||
.Dynamic => FifoType.init(testing.allocator),
|
||||
};
|
||||
defer fifo.deinit();
|
||||
|
||||
|
|
|
@ -1598,7 +1598,7 @@ test "hexToBytes" {
|
|||
test "formatIntValue with comptime_int" {
|
||||
const value: comptime_int = 123456789123456789;
|
||||
|
||||
var buf = try std.Buffer.init(std.debug.global_allocator, "");
|
||||
var buf = try std.Buffer.init(std.testing.allocator, "");
|
||||
try formatIntValue(value, "", FormatOptions{}, &buf, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append);
|
||||
std.testing.expect(mem.eql(u8, buf.toSlice(), "123456789123456789"));
|
||||
}
|
||||
|
@ -1652,19 +1652,19 @@ test "formatType max_depth" {
|
|||
inst.a = &inst;
|
||||
inst.tu.ptr = &inst.tu;
|
||||
|
||||
var buf0 = try std.Buffer.init(std.debug.global_allocator, "");
|
||||
var buf0 = try std.Buffer.init(std.testing.allocator, "");
|
||||
try formatType(inst, "", FormatOptions{}, &buf0, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 0);
|
||||
std.testing.expect(mem.eql(u8, buf0.toSlice(), "S{ ... }"));
|
||||
|
||||
var buf1 = try std.Buffer.init(std.debug.global_allocator, "");
|
||||
var buf1 = try std.Buffer.init(std.testing.allocator, "");
|
||||
try formatType(inst, "", FormatOptions{}, &buf1, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 1);
|
||||
std.testing.expect(mem.eql(u8, buf1.toSlice(), "S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }"));
|
||||
|
||||
var buf2 = try std.Buffer.init(std.debug.global_allocator, "");
|
||||
var buf2 = try std.Buffer.init(std.testing.allocator, "");
|
||||
try formatType(inst, "", FormatOptions{}, &buf2, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 2);
|
||||
std.testing.expect(mem.eql(u8, buf2.toSlice(), "S{ .a = S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ ... } }, .e = E.Two, .vec = (10.200,2.220) }"));
|
||||
|
||||
var buf3 = try std.Buffer.init(std.debug.global_allocator, "");
|
||||
var buf3 = try std.Buffer.init(std.testing.allocator, "");
|
||||
try formatType(inst, "", FormatOptions{}, &buf3, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 3);
|
||||
std.testing.expect(mem.eql(u8, buf3.toSlice(), "S{ .a = S{ .a = S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ ... } }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ .ptr = TU{ ... } } }, .e = E.Two, .vec = (10.200,2.220) }"));
|
||||
}
|
||||
|
|
|
@ -665,7 +665,7 @@ pub fn resolvePosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {
|
|||
}
|
||||
|
||||
test "resolve" {
|
||||
const cwd = try process.getCwdAlloc(debug.global_allocator);
|
||||
const cwd = try process.getCwdAlloc(testing.allocator);
|
||||
if (builtin.os == .windows) {
|
||||
if (windowsParsePath(cwd).kind == WindowsPath.Kind.Drive) {
|
||||
cwd[0] = asciiUpper(cwd[0]);
|
||||
|
@ -683,11 +683,11 @@ test "resolveWindows" {
|
|||
return error.SkipZigTest;
|
||||
}
|
||||
if (builtin.os == .windows) {
|
||||
const cwd = try process.getCwdAlloc(debug.global_allocator);
|
||||
const cwd = try process.getCwdAlloc(testing.allocator);
|
||||
const parsed_cwd = windowsParsePath(cwd);
|
||||
{
|
||||
const result = testResolveWindows(&[_][]const u8{ "/usr/local", "lib\\zig\\std\\array_list.zig" });
|
||||
const expected = try join(debug.global_allocator, &[_][]const u8{
|
||||
const expected = try join(testing.allocator, &[_][]const u8{
|
||||
parsed_cwd.disk_designator,
|
||||
"usr\\local\\lib\\zig\\std\\array_list.zig",
|
||||
});
|
||||
|
@ -698,7 +698,7 @@ test "resolveWindows" {
|
|||
}
|
||||
{
|
||||
const result = testResolveWindows(&[_][]const u8{ "usr/local", "lib\\zig" });
|
||||
const expected = try join(debug.global_allocator, &[_][]const u8{
|
||||
const expected = try join(testing.allocator, &[_][]const u8{
|
||||
cwd,
|
||||
"usr\\local\\lib\\zig",
|
||||
});
|
||||
|
@ -738,11 +738,11 @@ test "resolvePosix" {
|
|||
}
|
||||
|
||||
fn testResolveWindows(paths: []const []const u8) []u8 {
|
||||
return resolveWindows(debug.global_allocator, paths) catch unreachable;
|
||||
return resolveWindows(testing.allocator, paths) catch unreachable;
|
||||
}
|
||||
|
||||
fn testResolvePosix(paths: []const []const u8) []u8 {
|
||||
return resolvePosix(debug.global_allocator, paths) catch unreachable;
|
||||
return resolvePosix(testing.allocator, paths) catch unreachable;
|
||||
}
|
||||
|
||||
/// If the path is a file in the current directory (no directory component)
|
||||
|
@ -1166,11 +1166,11 @@ test "relative" {
|
|||
}
|
||||
|
||||
fn testRelativePosix(from: []const u8, to: []const u8, expected_output: []const u8) void {
|
||||
const result = relativePosix(debug.global_allocator, from, to) catch unreachable;
|
||||
const result = relativePosix(testing.allocator, from, to) catch unreachable;
|
||||
testing.expectEqualSlices(u8, expected_output, result);
|
||||
}
|
||||
|
||||
fn testRelativeWindows(from: []const u8, to: []const u8, expected_output: []const u8) void {
|
||||
const result = relativeWindows(debug.global_allocator, from, to) catch unreachable;
|
||||
const result = relativeWindows(testing.allocator, from, to) catch unreachable;
|
||||
testing.expectEqualSlices(u8, expected_output, result);
|
||||
}
|
||||
|
|
|
@ -711,6 +711,10 @@ pub const ThreadSafeFixedBufferAllocator = blk: {
|
|||
fn shrink(allocator: *Allocator, old_mem: []u8, old_align: u29, new_size: usize, new_align: u29) []u8 {
|
||||
return old_mem[0..new_size];
|
||||
}
|
||||
|
||||
pub fn reset(self: *ThreadSafeFixedBufferAllocator) void {
|
||||
self.end_index = 0;
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
|
|
|
@ -143,7 +143,7 @@ pub fn SinglyLinkedList(comptime T: type) type {
|
|||
}
|
||||
|
||||
test "basic SinglyLinkedList test" {
|
||||
const allocator = debug.global_allocator;
|
||||
const allocator = testing.allocator;
|
||||
var list = SinglyLinkedList(u32).init();
|
||||
|
||||
var one = try list.createNode(1, allocator);
|
||||
|
@ -404,7 +404,7 @@ pub fn TailQueue(comptime T: type) type {
|
|||
}
|
||||
|
||||
test "basic TailQueue test" {
|
||||
const allocator = debug.global_allocator;
|
||||
const allocator = testing.allocator;
|
||||
var list = TailQueue(u32).init();
|
||||
|
||||
var one = try list.createNode(1, allocator);
|
||||
|
@ -456,7 +456,7 @@ test "basic TailQueue test" {
|
|||
}
|
||||
|
||||
test "TailQueue concatenation" {
|
||||
const allocator = debug.global_allocator;
|
||||
const allocator = testing.allocator;
|
||||
var list1 = TailQueue(u32).init();
|
||||
var list2 = TailQueue(u32).init();
|
||||
|
||||
|
|
|
@ -9,7 +9,7 @@ const elf = std.elf;
|
|||
const File = std.fs.File;
|
||||
const Thread = std.Thread;
|
||||
|
||||
const a = std.debug.global_allocator;
|
||||
const a = std.testing.allocator;
|
||||
|
||||
const builtin = @import("builtin");
|
||||
const AtomicRmwOp = builtin.AtomicRmwOp;
|
||||
|
|
|
@ -1,10 +1,10 @@
|
|||
const std = @import("std.zig");
|
||||
const Allocator = std.mem.Allocator;
|
||||
const debug = std.debug;
|
||||
const assert = debug.assert;
|
||||
const expect = std.testing.expect;
|
||||
const expectEqual = std.testing.expectEqual;
|
||||
const expectError = std.testing.expectError;
|
||||
const assert = std.debug.assert;
|
||||
const testing = std.testing;
|
||||
const expect = testing.expect;
|
||||
const expectEqual = testing.expectEqual;
|
||||
const expectError = testing.expectError;
|
||||
|
||||
/// Priority queue for storing generic data. Initialize with `init`.
|
||||
pub fn PriorityQueue(comptime T: type) type {
|
||||
|
@ -239,7 +239,7 @@ fn greaterThan(a: u32, b: u32) bool {
|
|||
const PQ = PriorityQueue(u32);
|
||||
|
||||
test "std.PriorityQueue: add and remove min heap" {
|
||||
var queue = PQ.init(debug.global_allocator, lessThan);
|
||||
var queue = PQ.init(testing.allocator, lessThan);
|
||||
defer queue.deinit();
|
||||
|
||||
try queue.add(54);
|
||||
|
@ -257,7 +257,7 @@ test "std.PriorityQueue: add and remove min heap" {
|
|||
}
|
||||
|
||||
test "std.PriorityQueue: add and remove same min heap" {
|
||||
var queue = PQ.init(debug.global_allocator, lessThan);
|
||||
var queue = PQ.init(testing.allocator, lessThan);
|
||||
defer queue.deinit();
|
||||
|
||||
try queue.add(1);
|
||||
|
@ -275,14 +275,14 @@ test "std.PriorityQueue: add and remove same min heap" {
|
|||
}
|
||||
|
||||
test "std.PriorityQueue: removeOrNull on empty" {
|
||||
var queue = PQ.init(debug.global_allocator, lessThan);
|
||||
var queue = PQ.init(testing.allocator, lessThan);
|
||||
defer queue.deinit();
|
||||
|
||||
expect(queue.removeOrNull() == null);
|
||||
}
|
||||
|
||||
test "std.PriorityQueue: edge case 3 elements" {
|
||||
var queue = PQ.init(debug.global_allocator, lessThan);
|
||||
var queue = PQ.init(testing.allocator, lessThan);
|
||||
defer queue.deinit();
|
||||
|
||||
try queue.add(9);
|
||||
|
@ -294,7 +294,7 @@ test "std.PriorityQueue: edge case 3 elements" {
|
|||
}
|
||||
|
||||
test "std.PriorityQueue: peek" {
|
||||
var queue = PQ.init(debug.global_allocator, lessThan);
|
||||
var queue = PQ.init(testing.allocator, lessThan);
|
||||
defer queue.deinit();
|
||||
|
||||
expect(queue.peek() == null);
|
||||
|
@ -306,7 +306,7 @@ test "std.PriorityQueue: peek" {
|
|||
}
|
||||
|
||||
test "std.PriorityQueue: sift up with odd indices" {
|
||||
var queue = PQ.init(debug.global_allocator, lessThan);
|
||||
var queue = PQ.init(testing.allocator, lessThan);
|
||||
defer queue.deinit();
|
||||
const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
|
||||
for (items) |e| {
|
||||
|
@ -320,7 +320,7 @@ test "std.PriorityQueue: sift up with odd indices" {
|
|||
}
|
||||
|
||||
test "std.PriorityQueue: addSlice" {
|
||||
var queue = PQ.init(debug.global_allocator, lessThan);
|
||||
var queue = PQ.init(testing.allocator, lessThan);
|
||||
defer queue.deinit();
|
||||
const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
|
||||
try queue.addSlice(items[0..]);
|
||||
|
@ -333,8 +333,8 @@ test "std.PriorityQueue: addSlice" {
|
|||
|
||||
test "std.PriorityQueue: fromOwnedSlice" {
|
||||
const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
|
||||
const heap_items = try std.mem.dupe(debug.global_allocator, u32, items[0..]);
|
||||
var queue = PQ.fromOwnedSlice(debug.global_allocator, lessThan, heap_items[0..]);
|
||||
const heap_items = try std.mem.dupe(testing.allocator, u32, items[0..]);
|
||||
var queue = PQ.fromOwnedSlice(testing.allocator, lessThan, heap_items[0..]);
|
||||
defer queue.deinit();
|
||||
|
||||
const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
|
||||
|
@ -344,7 +344,7 @@ test "std.PriorityQueue: fromOwnedSlice" {
|
|||
}
|
||||
|
||||
test "std.PriorityQueue: add and remove max heap" {
|
||||
var queue = PQ.init(debug.global_allocator, greaterThan);
|
||||
var queue = PQ.init(testing.allocator, greaterThan);
|
||||
defer queue.deinit();
|
||||
|
||||
try queue.add(54);
|
||||
|
@ -362,7 +362,7 @@ test "std.PriorityQueue: add and remove max heap" {
|
|||
}
|
||||
|
||||
test "std.PriorityQueue: add and remove same max heap" {
|
||||
var queue = PQ.init(debug.global_allocator, greaterThan);
|
||||
var queue = PQ.init(testing.allocator, greaterThan);
|
||||
defer queue.deinit();
|
||||
|
||||
try queue.add(1);
|
||||
|
@ -380,8 +380,8 @@ test "std.PriorityQueue: add and remove same max heap" {
|
|||
}
|
||||
|
||||
test "std.PriorityQueue: iterator" {
|
||||
var queue = PQ.init(debug.global_allocator, lessThan);
|
||||
var map = std.AutoHashMap(u32, void).init(debug.global_allocator);
|
||||
var queue = PQ.init(testing.allocator, lessThan);
|
||||
var map = std.AutoHashMap(u32, void).init(testing.allocator);
|
||||
defer {
|
||||
queue.deinit();
|
||||
map.deinit();
|
||||
|
@ -402,7 +402,7 @@ test "std.PriorityQueue: iterator" {
|
|||
}
|
||||
|
||||
test "std.PriorityQueue: remove at index" {
|
||||
var queue = PQ.init(debug.global_allocator, lessThan);
|
||||
var queue = PQ.init(testing.allocator, lessThan);
|
||||
defer queue.deinit();
|
||||
|
||||
try queue.add(3);
|
||||
|
|
|
@ -114,7 +114,7 @@ pub fn getEnvMap(allocator: *Allocator) !BufMap {
|
|||
}
|
||||
|
||||
test "os.getEnvMap" {
|
||||
var env = try getEnvMap(std.debug.global_allocator);
|
||||
var env = try getEnvMap(std.testing.allocator);
|
||||
defer env.deinit();
|
||||
}
|
||||
|
||||
|
@ -165,7 +165,7 @@ pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) GetEnvVarOwned
|
|||
}
|
||||
|
||||
test "os.getEnvVarOwned" {
|
||||
var ga = std.debug.global_allocator;
|
||||
var ga = std.testing.allocator;
|
||||
testing.expectError(error.EnvironmentVariableNotFound, getEnvVarOwned(ga, "BADENV"));
|
||||
}
|
||||
|
||||
|
@ -492,10 +492,10 @@ test "windows arg parsing" {
|
|||
fn testWindowsCmdLine(input_cmd_line: [*]const u8, expected_args: []const []const u8) void {
|
||||
var it = ArgIteratorWindows.initWithCmdLine(input_cmd_line);
|
||||
for (expected_args) |expected_arg| {
|
||||
const arg = it.next(std.debug.global_allocator).? catch unreachable;
|
||||
const arg = it.next(std.testing.allocator).? catch unreachable;
|
||||
testing.expectEqualSlices(u8, expected_arg, arg);
|
||||
}
|
||||
testing.expect(it.next(std.debug.global_allocator) == null);
|
||||
testing.expect(it.next(std.testing.allocator) == null);
|
||||
}
|
||||
|
||||
pub const UserInfo = struct {
|
||||
|
|
|
@ -13,6 +13,7 @@ pub fn main() anyerror!void {
|
|||
};
|
||||
|
||||
for (test_fn_list) |test_fn, i| {
|
||||
std.testing.allocator_instance.reset();
|
||||
var test_node = root_node.start(test_fn.name, null);
|
||||
test_node.activate();
|
||||
progress.refresh();
|
||||
|
|
|
@ -2,6 +2,11 @@ const builtin = @import("builtin");
|
|||
const TypeId = builtin.TypeId;
|
||||
const std = @import("std.zig");
|
||||
|
||||
/// This should only be used in temporary test programs.
|
||||
pub const allocator = &allocator_instance.allocator;
|
||||
pub var allocator_instance = std.heap.ThreadSafeFixedBufferAllocator.init(allocator_mem[0..]);
|
||||
var allocator_mem: [100 * 1024]u8 = undefined;
|
||||
|
||||
/// This function is intended to be used only in tests. It prints diagnostics to stderr
|
||||
/// and then aborts when actual_error_union is not expected_error.
|
||||
pub fn expectError(expected_error: anyerror, actual_error_union: var) void {
|
||||
|
|
|
@ -501,14 +501,14 @@ test "utf16leToUtf8" {
|
|||
{
|
||||
mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 'A');
|
||||
mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 'a');
|
||||
const utf8 = try utf16leToUtf8Alloc(std.debug.global_allocator, &utf16le);
|
||||
const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
|
||||
testing.expect(mem.eql(u8, utf8, "Aa"));
|
||||
}
|
||||
|
||||
{
|
||||
mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0x80);
|
||||
mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xffff);
|
||||
const utf8 = try utf16leToUtf8Alloc(std.debug.global_allocator, &utf16le);
|
||||
const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
|
||||
testing.expect(mem.eql(u8, utf8, "\xc2\x80" ++ "\xef\xbf\xbf"));
|
||||
}
|
||||
|
||||
|
@ -516,7 +516,7 @@ test "utf16leToUtf8" {
|
|||
// the values just outside the surrogate half range
|
||||
mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xd7ff);
|
||||
mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xe000);
|
||||
const utf8 = try utf16leToUtf8Alloc(std.debug.global_allocator, &utf16le);
|
||||
const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
|
||||
testing.expect(mem.eql(u8, utf8, "\xed\x9f\xbf" ++ "\xee\x80\x80"));
|
||||
}
|
||||
|
||||
|
@ -524,7 +524,7 @@ test "utf16leToUtf8" {
|
|||
// smallest surrogate pair
|
||||
mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xd800);
|
||||
mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdc00);
|
||||
const utf8 = try utf16leToUtf8Alloc(std.debug.global_allocator, &utf16le);
|
||||
const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
|
||||
testing.expect(mem.eql(u8, utf8, "\xf0\x90\x80\x80"));
|
||||
}
|
||||
|
||||
|
@ -532,14 +532,14 @@ test "utf16leToUtf8" {
|
|||
// largest surrogate pair
|
||||
mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xdbff);
|
||||
mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdfff);
|
||||
const utf8 = try utf16leToUtf8Alloc(std.debug.global_allocator, &utf16le);
|
||||
const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
|
||||
testing.expect(mem.eql(u8, utf8, "\xf4\x8f\xbf\xbf"));
|
||||
}
|
||||
|
||||
{
|
||||
mem.writeIntSliceLittle(u16, utf16le_as_bytes[0..], 0xdbff);
|
||||
mem.writeIntSliceLittle(u16, utf16le_as_bytes[2..], 0xdc00);
|
||||
const utf8 = try utf16leToUtf8Alloc(std.debug.global_allocator, &utf16le);
|
||||
const utf8 = try utf16leToUtf8Alloc(std.testing.allocator, &utf16le);
|
||||
testing.expect(mem.eql(u8, utf8, "\xf4\x8f\xb0\x80"));
|
||||
}
|
||||
}
|
||||
|
|
|
@ -2287,7 +2287,7 @@ pub const Node = struct {
|
|||
test "iterate" {
|
||||
var root = Node.Root{
|
||||
.base = Node{ .id = Node.Id.Root },
|
||||
.decls = Node.Root.DeclList.init(std.debug.global_allocator),
|
||||
.decls = Node.Root.DeclList.init(std.testing.allocator),
|
||||
.eof_token = 0,
|
||||
};
|
||||
var base = &root.base;
|
||||
|
|
|
@ -445,7 +445,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
|
|||
\\const std = @import("std");
|
||||
\\const io = std.io;
|
||||
\\const os = std.os;
|
||||
\\const allocator = std.debug.global_allocator;
|
||||
\\const allocator = std.testing.allocator;
|
||||
\\
|
||||
\\pub fn main() !void {
|
||||
\\ var args_it = std.process.args();
|
||||
|
@ -486,7 +486,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
|
|||
\\const std = @import("std");
|
||||
\\const io = std.io;
|
||||
\\const os = std.os;
|
||||
\\const allocator = std.debug.global_allocator;
|
||||
\\const allocator = std.testing.allocator;
|
||||
\\
|
||||
\\pub fn main() !void {
|
||||
\\ var args_it = std.process.args();
|
||||
|
|
|
@ -5765,7 +5765,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
|
|||
\\
|
||||
\\export fn entry() void {
|
||||
\\ const a = MdNode.Header {
|
||||
\\ .text = MdText.init(&std.debug.global_allocator),
|
||||
\\ .text = MdText.init(&std.testing.allocator),
|
||||
\\ .weight = HeaderWeight.H1,
|
||||
\\ };
|
||||
\\}
|
||||
|
|
|
@ -22,7 +22,7 @@ fn foo(args: [][]const u8) void {
|
|||
}
|
||||
|
||||
fn bar(argc: usize) void {
|
||||
const args = debug.global_allocator.alloc([]const u8, argc) catch unreachable;
|
||||
const args = testing.allocator.alloc([]const u8, argc) catch unreachable;
|
||||
for (args) |_, i| {
|
||||
const ptr = argv[i];
|
||||
args[i] = ptr[0..strlen(ptr)];
|
||||
|
|
|
@ -201,7 +201,7 @@ pub fn main() !void {
|
|||
}
|
||||
|
||||
test "invalid inputs" {
|
||||
global_allocator = std.debug.global_allocator;
|
||||
global_allocator = std.testing.allocator;
|
||||
|
||||
expectError("}ABC", error.InvalidInput);
|
||||
expectError("{ABC", error.InvalidInput);
|
||||
|
@ -222,7 +222,7 @@ fn expectError(test_input: []const u8, expected_err: anyerror) void {
|
|||
}
|
||||
|
||||
test "valid inputs" {
|
||||
global_allocator = std.debug.global_allocator;
|
||||
global_allocator = std.testing.allocator;
|
||||
|
||||
expectExpansion("{x,y,z}", "x y z");
|
||||
expectExpansion("{A,B}{x,y}", "Ax Ay Bx By");
|
||||
|
|
|
@ -4,7 +4,7 @@ const process = std.process;
|
|||
const fs = std.fs;
|
||||
const mem = std.mem;
|
||||
const warn = std.debug.warn;
|
||||
const allocator = std.debug.global_allocator;
|
||||
const allocator = std.testing.allocator;
|
||||
|
||||
pub fn main() !void {
|
||||
var args_it = process.args();
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
const std = @import("std");
|
||||
|
||||
pub fn main() void {
|
||||
const env_map = std.process.getEnvMap(std.debug.global_allocator) catch @panic("unable to get env map");
|
||||
const env_map = std.process.getEnvMap(std.testing.allocator) catch @panic("unable to get env map");
|
||||
std.testing.expect(env_map.count() == 0);
|
||||
}
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
const std = @import("std");
|
||||
|
||||
pub fn main() !void {
|
||||
const args = try std.process.argsAlloc(std.debug.global_allocator);
|
||||
defer std.process.argsFree(std.debug.global_allocator, args);
|
||||
const args = try std.process.argsAlloc(std.testing.allocator);
|
||||
defer std.process.argsFree(std.testing.allocator, args);
|
||||
|
||||
const dynlib_name = args[1];
|
||||
|
||||
|
|
Loading…
Reference in New Issue