authorgravatar for benjamin.feng@glassdoor.comBenjamin Feng <benjamin.feng@glassdoor.com> 2020-01-31 19:06:50-06:00
committergravatar for benjamin.feng@glassdoor.comBenjamin Feng <benjamin.feng@glassdoor.com> 2020-02-12 17:17:56-06:00
log699c50a375fb6755a4116c94e6068620d070bd98
tree3ea0c8b81c73bd471cf9889fc9941a4939621a3f
parentab4ea5d3cf5a96cd596df14515521843ca4dccad

Switch a bunch of FBA to use testing.allocator

14 files changed, 58 insertions(+), 92 deletions(-)

lib/std/array_list.zig+3-11
......@@ -244,10 +244,7 @@ pub fn AlignedArrayList(comptime T: type, comptime alignment: ?u29) type {
244244}
245245
246246test "std.ArrayList.init" {
247 var bytes: [1024]u8 = undefined;
248 const allocator = &std.heap.FixedBufferAllocator.init(bytes[0..]).allocator;
249
250 var list = ArrayList(i32).init(allocator);
247 var list = ArrayList(i32).init(testing.allocator);
251248 defer list.deinit();
252249
253250 testing.expect(list.len == 0);
......@@ -255,19 +252,14 @@ test "std.ArrayList.init" {
255252}
256253
257254test "std.ArrayList.initCapacity" {
258 var bytes: [1024]u8 = undefined;
259 const allocator = &std.heap.FixedBufferAllocator.init(bytes[0..]).allocator;
260 var list = try ArrayList(i8).initCapacity(allocator, 200);
255 var list = try ArrayList(i8).initCapacity(testing.allocator, 200);
261256 defer list.deinit();
262257 testing.expect(list.len == 0);
263258 testing.expect(list.capacity() >= 200);
264259}
265260
266261test "std.ArrayList.basic" {
267 var bytes: [1024]u8 = undefined;
268 const allocator = &std.heap.FixedBufferAllocator.init(bytes[0..]).allocator;
269
270 var list = ArrayList(i32).init(allocator);
262 var list = ArrayList(i32).init(testing.allocator);
271263 defer list.deinit();
272264
273265 // setting on empty list is out of bounds
lib/std/ascii.zig+2-3
......@@ -236,9 +236,8 @@ pub fn allocLowerString(allocator: *std.mem.Allocator, ascii_string: []const u8)
236236}
237237
238238test "allocLowerString" {
239 var buf: [100]u8 = undefined;
240 const allocator = &std.heap.FixedBufferAllocator.init(&buf).allocator;
241 const result = try allocLowerString(allocator, "aBcDeFgHiJkLmNOPqrst0234+💩!");
239 const result = try allocLowerString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+💩!");
240 defer std.testing.allocator.free(result);
242241 std.testing.expect(std.mem.eql(u8, "abcdefghijklmnopqrst0234+💩!", result));
243242}
244243
lib/std/cstr.zig+2-3
......@@ -41,9 +41,8 @@ pub fn addNullByte(allocator: *mem.Allocator, slice: []const u8) ![:0]u8 {
4141}
4242
4343test "addNullByte" {
44 var buf: [30]u8 = undefined;
45 const allocator = &std.heap.FixedBufferAllocator.init(&buf).allocator;
46 const slice = try addNullByte(allocator, "hello"[0..4]);
44 const slice = try addNullByte(std.testing.allocator, "hello"[0..4]);
45 defer std.testing.allocator.free(slice);
4746 testing.expect(slice.len == 4);
4847 testing.expect(slice[4] == 0);
4948}
lib/std/fs/get_app_data_dir.zig+2-4
......@@ -56,9 +56,7 @@ pub fn getAppDataDir(allocator: *mem.Allocator, appname: []const u8) GetAppDataD
5656}
5757
5858test "getAppDataDir" {
59 var buf: [512]u8 = undefined;
60 const allocator = &std.heap.FixedBufferAllocator.init(buf[0..]).allocator;
61
6259 // We can't actually validate the result
63 _ = getAppDataDir(allocator, "zig") catch return;
60 const dir = getAppDataDir(std.testing.allocator, "zig") catch return;
61 defer std.testing.allocator.free(dir);
6462}
lib/std/fs/path.zig+4-6
......@@ -89,16 +89,14 @@ pub fn joinPosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {
8989}
9090
9191fn testJoinWindows(paths: []const []const u8, expected: []const u8) void {
92 var buf: [1024]u8 = undefined;
93 const a = &std.heap.FixedBufferAllocator.init(&buf).allocator;
94 const actual = joinWindows(a, paths) catch @panic("fail");
92 const actual = joinWindows(testing.allocator, paths) catch @panic("fail");
93 defer testing.allocator.free(actual);
9594 testing.expectEqualSlices(u8, expected, actual);
9695}
9796
9897fn testJoinPosix(paths: []const []const u8, expected: []const u8) void {
99 var buf: [1024]u8 = undefined;
100 const a = &std.heap.FixedBufferAllocator.init(&buf).allocator;
101 const actual = joinPosix(a, paths) catch @panic("fail");
98 const actual = joinPosix(testing.allocator, paths) catch @panic("fail");
99 defer testing.allocator.free(actual);
102100 testing.expectEqualSlices(u8, expected, actual);
103101}
104102
lib/std/http/headers.zig+22-26
......@@ -83,12 +83,8 @@ const HeaderEntry = struct {
8383 }
8484};
8585
86var test_memory: [32 * 1024]u8 = undefined;
87var test_fba_state = std.heap.FixedBufferAllocator.init(&test_memory);
88const test_allocator = &test_fba_state.allocator;
89
9086test "HeaderEntry" {
91 var e = try HeaderEntry.init(test_allocator, "foo", "bar", null);
87 var e = try HeaderEntry.init(testing.allocator, "foo", "bar", null);
9288 defer e.deinit();
9389 testing.expectEqualSlices(u8, "foo", e.name);
9490 testing.expectEqualSlices(u8, "bar", e.value);
......@@ -368,7 +364,7 @@ pub const Headers = struct {
368364};
369365
370366test "Headers.iterator" {
371 var h = Headers.init(test_allocator);
367 var h = Headers.init(testing.allocator);
372368 defer h.deinit();
373369 try h.append("foo", "bar", null);
374370 try h.append("cookie", "somevalue", null);
......@@ -390,7 +386,7 @@ test "Headers.iterator" {
390386}
391387
392388test "Headers.contains" {
393 var h = Headers.init(test_allocator);
389 var h = Headers.init(testing.allocator);
394390 defer h.deinit();
395391 try h.append("foo", "bar", null);
396392 try h.append("cookie", "somevalue", null);
......@@ -400,7 +396,7 @@ test "Headers.contains" {
400396}
401397
402398test "Headers.delete" {
403 var h = Headers.init(test_allocator);
399 var h = Headers.init(testing.allocator);
404400 defer h.deinit();
405401 try h.append("foo", "bar", null);
406402 try h.append("baz", "qux", null);
......@@ -428,7 +424,7 @@ test "Headers.delete" {
428424}
429425
430426test "Headers.orderedRemove" {
431 var h = Headers.init(test_allocator);
427 var h = Headers.init(testing.allocator);
432428 defer h.deinit();
433429 try h.append("foo", "bar", null);
434430 try h.append("baz", "qux", null);
......@@ -451,7 +447,7 @@ test "Headers.orderedRemove" {
451447}
452448
453449test "Headers.swapRemove" {
454 var h = Headers.init(test_allocator);
450 var h = Headers.init(testing.allocator);
455451 defer h.deinit();
456452 try h.append("foo", "bar", null);
457453 try h.append("baz", "qux", null);
......@@ -474,7 +470,7 @@ test "Headers.swapRemove" {
474470}
475471
476472test "Headers.at" {
477 var h = Headers.init(test_allocator);
473 var h = Headers.init(testing.allocator);
478474 defer h.deinit();
479475 try h.append("foo", "bar", null);
480476 try h.append("cookie", "somevalue", null);
......@@ -494,7 +490,7 @@ test "Headers.at" {
494490}
495491
496492test "Headers.getIndices" {
497 var h = Headers.init(test_allocator);
493 var h = Headers.init(testing.allocator);
498494 defer h.deinit();
499495 try h.append("foo", "bar", null);
500496 try h.append("set-cookie", "x=1", null);
......@@ -506,27 +502,27 @@ test "Headers.getIndices" {
506502}
507503
508504test "Headers.get" {
509 var h = Headers.init(test_allocator);
505 var h = Headers.init(testing.allocator);
510506 defer h.deinit();
511507 try h.append("foo", "bar", null);
512508 try h.append("set-cookie", "x=1", null);
513509 try h.append("set-cookie", "y=2", null);
514510
515511 {
516 const v = try h.get(test_allocator, "not-present");
512 const v = try h.get(testing.allocator, "not-present");
517513 testing.expect(null == v);
518514 }
519515 {
520 const v = (try h.get(test_allocator, "foo")).?;
521 defer test_allocator.free(v);
516 const v = (try h.get(testing.allocator, "foo")).?;
517 defer testing.allocator.free(v);
522518 const e = v[0];
523519 testing.expectEqualSlices(u8, "foo", e.name);
524520 testing.expectEqualSlices(u8, "bar", e.value);
525521 testing.expectEqual(false, e.never_index);
526522 }
527523 {
528 const v = (try h.get(test_allocator, "set-cookie")).?;
529 defer test_allocator.free(v);
524 const v = (try h.get(testing.allocator, "set-cookie")).?;
525 defer testing.allocator.free(v);
530526 {
531527 const e = v[0];
532528 testing.expectEqualSlices(u8, "set-cookie", e.name);
......@@ -543,30 +539,30 @@ test "Headers.get" {
543539}
544540
545541test "Headers.getCommaSeparated" {
546 var h = Headers.init(test_allocator);
542 var h = Headers.init(testing.allocator);
547543 defer h.deinit();
548544 try h.append("foo", "bar", null);
549545 try h.append("set-cookie", "x=1", null);
550546 try h.append("set-cookie", "y=2", null);
551547
552548 {
553 const v = try h.getCommaSeparated(test_allocator, "not-present");
549 const v = try h.getCommaSeparated(testing.allocator, "not-present");
554550 testing.expect(null == v);
555551 }
556552 {
557 const v = (try h.getCommaSeparated(test_allocator, "foo")).?;
558 defer test_allocator.free(v);
553 const v = (try h.getCommaSeparated(testing.allocator, "foo")).?;
554 defer testing.allocator.free(v);
559555 testing.expectEqualSlices(u8, "bar", v);
560556 }
561557 {
562 const v = (try h.getCommaSeparated(test_allocator, "set-cookie")).?;
563 defer test_allocator.free(v);
558 const v = (try h.getCommaSeparated(testing.allocator, "set-cookie")).?;
559 defer testing.allocator.free(v);
564560 testing.expectEqualSlices(u8, "x=1,y=2", v);
565561 }
566562}
567563
568564test "Headers.sort" {
569 var h = Headers.init(test_allocator);
565 var h = Headers.init(testing.allocator);
570566 defer h.deinit();
571567 try h.append("foo", "bar", null);
572568 try h.append("cookie", "somevalue", null);
......@@ -587,7 +583,7 @@ test "Headers.sort" {
587583}
588584
589585test "Headers.format" {
590 var h = Headers.init(test_allocator);
586 var h = Headers.init(testing.allocator);
591587 defer h.deinit();
592588 try h.append("foo", "bar", null);
593589 try h.append("cookie", "somevalue", null);
lib/std/io.zig+4-8
......@@ -223,15 +223,13 @@ test "io.BufferedInStream" {
223223 }
224224 };
225225
226 var buf: [100]u8 = undefined;
227 const allocator = &std.heap.FixedBufferAllocator.init(buf[0..]).allocator;
228
229226 const str = "This is a test";
230227 var one_byte_stream = OneByteReadInStream.init(str);
231228 var buf_in_stream = BufferedInStream(OneByteReadInStream.Error).init(&one_byte_stream.stream);
232229 const stream = &buf_in_stream.stream;
233230
234 const res = try stream.readAllAlloc(allocator, str.len + 1);
231 const res = try stream.readAllAlloc(testing.allocator, str.len + 1);
232 defer testing.allocator.free(res);
235233 testing.expectEqualSlices(u8, str, res);
236234}
237235
......@@ -874,10 +872,8 @@ pub fn readLineFrom(stream: var, buf: *std.Buffer) ![]u8 {
874872}
875873
876874test "io.readLineFrom" {
877 var bytes: [128]u8 = undefined;
878 const allocator = &std.heap.FixedBufferAllocator.init(bytes[0..]).allocator;
879
880 var buf = try std.Buffer.initSize(allocator, 0);
875 var buf = try std.Buffer.initSize(testing.allocator, 0);
876 defer buf.deinit();
881877 var mem_stream = SliceInStream.init(
882878 \\Line 1
883879 \\Line 22
lib/std/io/test.zig+4-9
......@@ -11,9 +11,6 @@ const fs = std.fs;
1111const File = std.fs.File;
1212
1313test "write a file, read it, then delete it" {
14 var raw_bytes: [200 * 1024]u8 = undefined;
15 var allocator = &std.heap.FixedBufferAllocator.init(raw_bytes[0..]).allocator;
16
1714 const cwd = fs.cwd();
1815
1916 var data: [1024]u8 = undefined;
......@@ -53,8 +50,8 @@ test "write a file, read it, then delete it" {
5350 var file_in_stream = file.inStream();
5451 var buf_stream = io.BufferedInStream(File.ReadError).init(&file_in_stream.stream);
5552 const st = &buf_stream.stream;
56 const contents = try st.readAllAlloc(allocator, 2 * 1024);
57 defer allocator.free(contents);
53 const contents = try st.readAllAlloc(std.testing.allocator, 2 * 1024);
54 defer std.testing.allocator.free(contents);
5855
5956 expect(mem.eql(u8, contents[0.."begin".len], "begin"));
6057 expect(mem.eql(u8, contents["begin".len .. contents.len - "end".len], &data));
......@@ -64,10 +61,8 @@ test "write a file, read it, then delete it" {
6461}
6562
6663test "BufferOutStream" {
67 var bytes: [100]u8 = undefined;
68 var allocator = &std.heap.FixedBufferAllocator.init(bytes[0..]).allocator;
69
70 var buffer = try std.Buffer.initSize(allocator, 0);
64 var buffer = try std.Buffer.initSize(std.testing.allocator, 0);
65 defer buffer.deinit();
7166 var buf_stream = &std.io.BufferOutStream.init(&buffer).stream;
7267
7368 const x: i32 = 42;
lib/std/os/test.zig+2-3
......@@ -95,8 +95,6 @@ test "cpu count" {
9595}
9696
9797test "AtomicFile" {
98 var buffer: [1024]u8 = undefined;
99 const allocator = &std.heap.FixedBufferAllocator.init(buffer[0..]).allocator;
10098 const test_out_file = "tmp_atomic_file_test_dest.txt";
10199 const test_content =
102100 \\ hello!
......@@ -108,7 +106,8 @@ test "AtomicFile" {
108106 try af.file.write(test_content);
109107 try af.finish();
110108 }
111 const content = try io.readFileAlloc(allocator, test_out_file);
109 const content = try io.readFileAlloc(testing.allocator, test_out_file);
110 defer testing.allocator.free(content);
112111 expect(mem.eql(u8, content, test_content));
113112
114113 try fs.cwd().deleteFile(test_out_file);
lib/std/process.zig+2-4
......@@ -27,10 +27,8 @@ pub fn getCwdAlloc(allocator: *Allocator) ![]u8 {
2727}
2828
2929test "getCwdAlloc" {
30 // at least call it so it gets compiled
31 var buf: [1000]u8 = undefined;
32 const allocator = &std.heap.FixedBufferAllocator.init(&buf).allocator;
33 _ = getCwdAlloc(allocator) catch undefined;
30 const cwd = try getCwdAlloc(testing.allocator);
31 testing.allocator.free(cwd);
3432}
3533
3634/// Caller must free result when done.
lib/std/sort.zig+4-4
......@@ -1220,16 +1220,16 @@ test "sort fuzz testing" {
12201220 const test_case_count = 10;
12211221 var i: usize = 0;
12221222 while (i < test_case_count) : (i += 1) {
1223 fuzzTest(&prng.random);
1223 try fuzzTest(&prng.random);
12241224 }
12251225}
12261226
12271227var fixed_buffer_mem: [100 * 1024]u8 = undefined;
12281228
1229fn fuzzTest(rng: *std.rand.Random) void {
1229fn fuzzTest(rng: *std.rand.Random) !void {
12301230 const array_size = rng.range(usize, 0, 1000);
1231 var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
1232 var array = fixed_allocator.allocator.alloc(IdAndValue, array_size) catch unreachable;
1231 var array = try testing.allocator.alloc(IdAndValue, array_size);
1232 defer testing.allocator.free(array);
12331233 // populate with random data
12341234 for (array) |*item, index| {
12351235 item.id = index;
lib/std/unicode.zig+4-6
......@@ -617,16 +617,14 @@ test "utf8ToUtf16Le" {
617617
618618test "utf8ToUtf16LeWithNull" {
619619 {
620 var bytes: [128]u8 = undefined;
621 const allocator = &std.heap.FixedBufferAllocator.init(bytes[0..]).allocator;
622 const utf16 = try utf8ToUtf16LeWithNull(allocator, "𐐷");
620 const utf16 = try utf8ToUtf16LeWithNull(testing.allocator, "𐐷");
621 defer testing.allocator.free(utf16);
623622 testing.expectEqualSlices(u8, "\x01\xd8\x37\xdc", @sliceToBytes(utf16[0..]));
624623 testing.expect(utf16[2] == 0);
625624 }
626625 {
627 var bytes: [128]u8 = undefined;
628 const allocator = &std.heap.FixedBufferAllocator.init(bytes[0..]).allocator;
629 const utf16 = try utf8ToUtf16LeWithNull(allocator, "\u{10FFFF}");
626 const utf16 = try utf8ToUtf16LeWithNull(testing.allocator, "\u{10FFFF}");
627 defer testing.allocator.free(utf16);
630628 testing.expectEqualSlices(u8, "\xff\xdb\xff\xdf", @sliceToBytes(utf16[0..]));
631629 testing.expect(utf16[2] == 0);
632630 }
lib/std/zig/parser_test.zig+1-2
......@@ -2886,8 +2886,7 @@ fn testCanonical(source: []const u8) !void {
28862886}
28872887
28882888fn testError(source: []const u8) !void {
2889 var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
2890 const tree = try std.zig.parse(&fixed_allocator.allocator, source);
2889 const tree = try std.zig.parse(std.testing.allocator, source);
28912890 defer tree.deinit();
28922891
28932892 std.testing.expect(tree.errors.len != 0);
test/stage1/behavior/bugs/1851.zig+2-3
......@@ -6,10 +6,9 @@ test "allocation and looping over 3-byte integer" {
66 expect(@sizeOf([1]u24) == 4);
77 expect(@alignOf(u24) == 4);
88 expect(@alignOf([1]u24) == 4);
9 var buffer: [100]u8 = undefined;
10 const a = &std.heap.FixedBufferAllocator.init(&buffer).allocator;
119
12 var x = a.alloc(u24, 2) catch unreachable;
10 var x = try std.testing.allocator.alloc(u24, 2);
11 defer std.testing.allocator.free(x);
1312 expect(x.len == 2);
1413 x[0] = 0xFFFFFF;
1514 x[1] = 0xFFFFFF;