authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2022-06-03 16:02:23+03:00
committergravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2022-06-03 20:21:20+03:00
log6d44c0a16c90a13cb3507751e2015edf51c642cf
tree6dfa9b43c776a3a34fad7aedada8b76b5eac5ac2
parent1a7b4ddeaedb81255cfa8907958c3cf09dd340ee

std: update tests to stage2 semantics

11 files changed, 262 insertions(+), 144 deletions(-)

lib/std/crypto/25519/scalar.zig+8-4
...@@ -34,12 +34,14 @@ pub fn rejectNonCanonical(s: CompressedScalar) NonCanonicalError!void {...@@ -34,12 +34,14 @@ pub fn rejectNonCanonical(s: CompressedScalar) NonCanonicalError!void {
3434
35/// Reduce a scalar to the field size.35/// Reduce a scalar to the field size.
36pub fn reduce(s: CompressedScalar) CompressedScalar {36pub fn reduce(s: CompressedScalar) CompressedScalar {
37 return Scalar.fromBytes(s).toBytes();37 var scalar = Scalar.fromBytes(s);
38 return scalar.toBytes();
38}39}
3940
40/// Reduce a 64-bytes scalar to the field size.41/// Reduce a 64-bytes scalar to the field size.
41pub fn reduce64(s: [64]u8) CompressedScalar {42pub fn reduce64(s: [64]u8) CompressedScalar {
42 return ScalarDouble.fromBytes64(s).toBytes();43 var scalar = ScalarDouble.fromBytes64(s);
44 return scalar.toBytes();
43}45}
4446
45/// Perform the X25519 "clamping" operation.47/// Perform the X25519 "clamping" operation.
...@@ -106,12 +108,14 @@ pub const Scalar = struct {...@@ -106,12 +108,14 @@ pub const Scalar = struct {
106108
107 /// Unpack a 32-byte representation of a scalar109 /// Unpack a 32-byte representation of a scalar
108 pub fn fromBytes(bytes: CompressedScalar) Scalar {110 pub fn fromBytes(bytes: CompressedScalar) Scalar {
109 return ScalarDouble.fromBytes32(bytes).reduce(5);111 var scalar = ScalarDouble.fromBytes32(bytes);
112 return scalar.reduce(5);
110 }113 }
111114
112 /// Unpack a 64-byte representation of a scalar115 /// Unpack a 64-byte representation of a scalar
113 pub fn fromBytes64(bytes: [64]u8) Scalar {116 pub fn fromBytes64(bytes: [64]u8) Scalar {
114 return ScalarDouble.fromBytes64(bytes).reduce(5);117 var scalar = ScalarDouble.fromBytes64(bytes);
118 return scalar.reduce(5);
115 }119 }
116120
117 /// Pack a scalar into bytes121 /// Pack a scalar into bytes
lib/std/crypto/blake3.zig+6-3
...@@ -679,9 +679,12 @@ fn testBlake3(hasher: *Blake3, input_len: usize, expected_hex: [262]u8) !void {...@@ -679,9 +679,12 @@ fn testBlake3(hasher: *Blake3, input_len: usize, expected_hex: [262]u8) !void {
679}679}
680680
681test "BLAKE3 reference test cases" {681test "BLAKE3 reference test cases" {
682 var hash = &Blake3.init(.{});682 var hash_state = Blake3.init(.{});
683 var keyed_hash = &Blake3.init(.{ .key = reference_test.key.* });683 const hash = &hash_state;
684 var derive_key = &Blake3.initKdf(reference_test.context_string, .{});684 var keyed_hash_state = Blake3.init(.{ .key = reference_test.key.* });
685 const keyed_hash = &keyed_hash_state;
686 var derive_key_state = Blake3.initKdf(reference_test.context_string, .{});
687 const derive_key = &derive_key_state;
685688
686 for (reference_test.cases) |t| {689 for (reference_test.cases) |t| {
687 try testBlake3(hash, t.input_len, t.hash.*);690 try testBlake3(hash, t.input_len, t.hash.*);
lib/std/crypto/sha3.zig+3-5
...@@ -128,18 +128,16 @@ fn keccakF(comptime F: usize, d: *[F / 8]u8) void {...@@ -128,18 +128,16 @@ fn keccakF(comptime F: usize, d: *[F / 8]u8) void {
128 r.* = mem.readIntLittle(u64, d[8 * i ..][0..8]);128 r.* = mem.readIntLittle(u64, d[8 * i ..][0..8]);
129 }129 }
130130
131 comptime var x: usize = 0;
132 comptime var y: usize = 0;
133 for (RC[0..no_rounds]) |round| {131 for (RC[0..no_rounds]) |round| {
134 // theta132 // theta
135 x = 0;133 comptime var x: usize = 0;
136 inline while (x < 5) : (x += 1) {134 inline while (x < 5) : (x += 1) {
137 c[x] = s[x] ^ s[x + 5] ^ s[x + 10] ^ s[x + 15] ^ s[x + 20];135 c[x] = s[x] ^ s[x + 5] ^ s[x + 10] ^ s[x + 15] ^ s[x + 20];
138 }136 }
139 x = 0;137 x = 0;
140 inline while (x < 5) : (x += 1) {138 inline while (x < 5) : (x += 1) {
141 t[0] = c[M5[x + 4]] ^ math.rotl(u64, c[M5[x + 1]], @as(usize, 1));139 t[0] = c[M5[x + 4]] ^ math.rotl(u64, c[M5[x + 1]], @as(usize, 1));
142 y = 0;140 comptime var y: usize = 0;
143 inline while (y < 5) : (y += 1) {141 inline while (y < 5) : (y += 1) {
144 s[x + y * 5] ^= t[0];142 s[x + y * 5] ^= t[0];
145 }143 }
...@@ -155,7 +153,7 @@ fn keccakF(comptime F: usize, d: *[F / 8]u8) void {...@@ -155,7 +153,7 @@ fn keccakF(comptime F: usize, d: *[F / 8]u8) void {
155 }153 }
156154
157 // chi155 // chi
158 y = 0;156 comptime var y: usize = 0;
159 inline while (y < 5) : (y += 1) {157 inline while (y < 5) : (y += 1) {
160 x = 0;158 x = 0;
161 inline while (x < 5) : (x += 1) {159 inline while (x < 5) : (x += 1) {
lib/std/fmt.zig+1
...@@ -2123,6 +2123,7 @@ test "pointer" {...@@ -2123,6 +2123,7 @@ test "pointer" {
2123 try expectFmt("pointer: i32@deadbeef\n", "pointer: {}\n", .{value});2123 try expectFmt("pointer: i32@deadbeef\n", "pointer: {}\n", .{value});
2124 try expectFmt("pointer: i32@deadbeef\n", "pointer: {*}\n", .{value});2124 try expectFmt("pointer: i32@deadbeef\n", "pointer: {*}\n", .{value});
2125 }2125 }
2126 if (builtin.zig_backend != .stage1) return error.SkipZigTest;
2126 {2127 {
2127 const value = @intToPtr(fn () void, 0xdeadbeef);2128 const value = @intToPtr(fn () void, 0xdeadbeef);
2128 try expectFmt("pointer: fn() void@deadbeef\n", "pointer: {}\n", .{value});2129 try expectFmt("pointer: fn() void@deadbeef\n", "pointer: {}\n", .{value});
lib/std/heap.zig+2-1
...@@ -1210,7 +1210,8 @@ pub fn testAllocatorAlignedShrink(base_allocator: mem.Allocator) !void {...@@ -1210,7 +1210,8 @@ pub fn testAllocatorAlignedShrink(base_allocator: mem.Allocator) !void {
1210 const allocator = validationAllocator.allocator();1210 const allocator = validationAllocator.allocator();
12111211
1212 var debug_buffer: [1000]u8 = undefined;1212 var debug_buffer: [1000]u8 = undefined;
1213 const debug_allocator = FixedBufferAllocator.init(&debug_buffer).allocator();1213 var fib = FixedBufferAllocator.init(&debug_buffer);
1214 const debug_allocator = fib.allocator();
12141215
1215 const alloc_size = mem.page_size * 2 + 50;1216 const alloc_size = mem.page_size * 2 + 50;
1216 var slice = try allocator.alignedAlloc(u8, 16, alloc_size);1217 var slice = try allocator.alignedAlloc(u8, 16, alloc_size);
lib/std/heap/log_to_writer_allocator.zig+2-1
...@@ -91,7 +91,8 @@ test "LogToWriterAllocator" {...@@ -91,7 +91,8 @@ test "LogToWriterAllocator" {
9191
92 var allocator_buf: [10]u8 = undefined;92 var allocator_buf: [10]u8 = undefined;
93 var fixedBufferAllocator = std.mem.validationWrap(std.heap.FixedBufferAllocator.init(&allocator_buf));93 var fixedBufferAllocator = std.mem.validationWrap(std.heap.FixedBufferAllocator.init(&allocator_buf));
94 const allocator = logToWriterAllocator(fixedBufferAllocator.allocator(), fbs.writer()).allocator();94 var allocator_state = logToWriterAllocator(fixedBufferAllocator.allocator(), fbs.writer());
95 const allocator = allocator_state.allocator();
9596
96 var a = try allocator.alloc(u8, 10);97 var a = try allocator.alloc(u8, 10);
97 a = allocator.shrink(a, 5);98 a = allocator.shrink(a, 5);
lib/std/io/reader.zig+64-32
...@@ -344,7 +344,8 @@ pub fn Reader(...@@ -344,7 +344,8 @@ pub fn Reader(
344344
345test "Reader" {345test "Reader" {
346 var buf = "a\x02".*;346 var buf = "a\x02".*;
347 const reader = std.io.fixedBufferStream(&buf).reader();347 var fis = std.io.fixedBufferStream(&buf);
348 const reader = fis.reader();
348 try testing.expect((try reader.readByte()) == 'a');349 try testing.expect((try reader.readByte()) == 'a');
349 try testing.expect((try reader.readEnum(enum(u8) {350 try testing.expect((try reader.readEnum(enum(u8) {
350 a = 0,351 a = 0,
...@@ -356,13 +357,15 @@ test "Reader" {...@@ -356,13 +357,15 @@ test "Reader" {
356}357}
357358
358test "Reader.isBytes" {359test "Reader.isBytes" {
359 const reader = std.io.fixedBufferStream("foobar").reader();360 var fis = std.io.fixedBufferStream("foobar");
361 const reader = fis.reader();
360 try testing.expectEqual(true, try reader.isBytes("foo"));362 try testing.expectEqual(true, try reader.isBytes("foo"));
361 try testing.expectEqual(false, try reader.isBytes("qux"));363 try testing.expectEqual(false, try reader.isBytes("qux"));
362}364}
363365
364test "Reader.skipBytes" {366test "Reader.skipBytes" {
365 const reader = std.io.fixedBufferStream("foobar").reader();367 var fis = std.io.fixedBufferStream("foobar");
368 const reader = fis.reader();
366 try reader.skipBytes(3, .{});369 try reader.skipBytes(3, .{});
367 try testing.expect(try reader.isBytes("bar"));370 try testing.expect(try reader.isBytes("bar"));
368 try reader.skipBytes(0, .{});371 try reader.skipBytes(0, .{});
...@@ -374,7 +377,8 @@ test "Reader.readUntilDelimiterArrayList returns ArrayLists with bytes read unti...@@ -374,7 +377,8 @@ test "Reader.readUntilDelimiterArrayList returns ArrayLists with bytes read unti
374 var list = std.ArrayList(u8).init(a);377 var list = std.ArrayList(u8).init(a);
375 defer list.deinit();378 defer list.deinit();
376379
377 const reader = std.io.fixedBufferStream("0000\n1234\n").reader();380 var fis = std.io.fixedBufferStream("0000\n1234\n");
381 const reader = fis.reader();
378382
379 try reader.readUntilDelimiterArrayList(&list, '\n', 5);383 try reader.readUntilDelimiterArrayList(&list, '\n', 5);
380 try std.testing.expectEqualStrings("0000", list.items);384 try std.testing.expectEqualStrings("0000", list.items);
...@@ -388,7 +392,8 @@ test "Reader.readUntilDelimiterArrayList returns an empty ArrayList" {...@@ -388,7 +392,8 @@ test "Reader.readUntilDelimiterArrayList returns an empty ArrayList" {
388 var list = std.ArrayList(u8).init(a);392 var list = std.ArrayList(u8).init(a);
389 defer list.deinit();393 defer list.deinit();
390394
391 const reader = std.io.fixedBufferStream("\n").reader();395 var fis = std.io.fixedBufferStream("\n");
396 const reader = fis.reader();
392397
393 try reader.readUntilDelimiterArrayList(&list, '\n', 5);398 try reader.readUntilDelimiterArrayList(&list, '\n', 5);
394 try std.testing.expectEqualStrings("", list.items);399 try std.testing.expectEqualStrings("", list.items);
...@@ -399,7 +404,8 @@ test "Reader.readUntilDelimiterArrayList returns StreamTooLong, then an ArrayLis...@@ -399,7 +404,8 @@ test "Reader.readUntilDelimiterArrayList returns StreamTooLong, then an ArrayLis
399 var list = std.ArrayList(u8).init(a);404 var list = std.ArrayList(u8).init(a);
400 defer list.deinit();405 defer list.deinit();
401406
402 const reader = std.io.fixedBufferStream("1234567\n").reader();407 var fis = std.io.fixedBufferStream("1234567\n");
408 const reader = fis.reader();
403409
404 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterArrayList(&list, '\n', 5));410 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterArrayList(&list, '\n', 5));
405 try std.testing.expectEqualStrings("12345", list.items);411 try std.testing.expectEqualStrings("12345", list.items);
...@@ -412,7 +418,8 @@ test "Reader.readUntilDelimiterArrayList returns EndOfStream" {...@@ -412,7 +418,8 @@ test "Reader.readUntilDelimiterArrayList returns EndOfStream" {
412 var list = std.ArrayList(u8).init(a);418 var list = std.ArrayList(u8).init(a);
413 defer list.deinit();419 defer list.deinit();
414420
415 const reader = std.io.fixedBufferStream("1234").reader();421 var fis = std.io.fixedBufferStream("1234");
422 const reader = fis.reader();
416423
417 try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiterArrayList(&list, '\n', 5));424 try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiterArrayList(&list, '\n', 5));
418 try std.testing.expectEqualStrings("1234", list.items);425 try std.testing.expectEqualStrings("1234", list.items);
...@@ -421,7 +428,8 @@ test "Reader.readUntilDelimiterArrayList returns EndOfStream" {...@@ -421,7 +428,8 @@ test "Reader.readUntilDelimiterArrayList returns EndOfStream" {
421test "Reader.readUntilDelimiterAlloc returns ArrayLists with bytes read until the delimiter, then EndOfStream" {428test "Reader.readUntilDelimiterAlloc returns ArrayLists with bytes read until the delimiter, then EndOfStream" {
422 const a = std.testing.allocator;429 const a = std.testing.allocator;
423430
424 const reader = std.io.fixedBufferStream("0000\n1234\n").reader();431 var fis = std.io.fixedBufferStream("0000\n1234\n");
432 const reader = fis.reader();
425433
426 {434 {
427 var result = try reader.readUntilDelimiterAlloc(a, '\n', 5);435 var result = try reader.readUntilDelimiterAlloc(a, '\n', 5);
...@@ -441,7 +449,8 @@ test "Reader.readUntilDelimiterAlloc returns ArrayLists with bytes read until th...@@ -441,7 +449,8 @@ test "Reader.readUntilDelimiterAlloc returns ArrayLists with bytes read until th
441test "Reader.readUntilDelimiterAlloc returns an empty ArrayList" {449test "Reader.readUntilDelimiterAlloc returns an empty ArrayList" {
442 const a = std.testing.allocator;450 const a = std.testing.allocator;
443451
444 const reader = std.io.fixedBufferStream("\n").reader();452 var fis = std.io.fixedBufferStream("\n");
453 const reader = fis.reader();
445454
446 {455 {
447 var result = try reader.readUntilDelimiterAlloc(a, '\n', 5);456 var result = try reader.readUntilDelimiterAlloc(a, '\n', 5);
...@@ -453,7 +462,8 @@ test "Reader.readUntilDelimiterAlloc returns an empty ArrayList" {...@@ -453,7 +462,8 @@ test "Reader.readUntilDelimiterAlloc returns an empty ArrayList" {
453test "Reader.readUntilDelimiterAlloc returns StreamTooLong, then an ArrayList with bytes read until the delimiter" {462test "Reader.readUntilDelimiterAlloc returns StreamTooLong, then an ArrayList with bytes read until the delimiter" {
454 const a = std.testing.allocator;463 const a = std.testing.allocator;
455464
456 const reader = std.io.fixedBufferStream("1234567\n").reader();465 var fis = std.io.fixedBufferStream("1234567\n");
466 const reader = fis.reader();
457467
458 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterAlloc(a, '\n', 5));468 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterAlloc(a, '\n', 5));
459469
...@@ -465,67 +475,77 @@ test "Reader.readUntilDelimiterAlloc returns StreamTooLong, then an ArrayList wi...@@ -465,67 +475,77 @@ test "Reader.readUntilDelimiterAlloc returns StreamTooLong, then an ArrayList wi
465test "Reader.readUntilDelimiterAlloc returns EndOfStream" {475test "Reader.readUntilDelimiterAlloc returns EndOfStream" {
466 const a = std.testing.allocator;476 const a = std.testing.allocator;
467477
468 const reader = std.io.fixedBufferStream("1234").reader();478 var fis = std.io.fixedBufferStream("1234");
479 const reader = fis.reader();
469480
470 try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiterAlloc(a, '\n', 5));481 try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiterAlloc(a, '\n', 5));
471}482}
472483
473test "Reader.readUntilDelimiter returns bytes read until the delimiter" {484test "Reader.readUntilDelimiter returns bytes read until the delimiter" {
474 var buf: [5]u8 = undefined;485 var buf: [5]u8 = undefined;
475 const reader = std.io.fixedBufferStream("0000\n1234\n").reader();486 var fis = std.io.fixedBufferStream("0000\n1234\n");
487 const reader = fis.reader();
476 try std.testing.expectEqualStrings("0000", try reader.readUntilDelimiter(&buf, '\n'));488 try std.testing.expectEqualStrings("0000", try reader.readUntilDelimiter(&buf, '\n'));
477 try std.testing.expectEqualStrings("1234", try reader.readUntilDelimiter(&buf, '\n'));489 try std.testing.expectEqualStrings("1234", try reader.readUntilDelimiter(&buf, '\n'));
478}490}
479491
480test "Reader.readUntilDelimiter returns an empty string" {492test "Reader.readUntilDelimiter returns an empty string" {
481 var buf: [5]u8 = undefined;493 var buf: [5]u8 = undefined;
482 const reader = std.io.fixedBufferStream("\n").reader();494 var fis = std.io.fixedBufferStream("\n");
495 const reader = fis.reader();
483 try std.testing.expectEqualStrings("", try reader.readUntilDelimiter(&buf, '\n'));496 try std.testing.expectEqualStrings("", try reader.readUntilDelimiter(&buf, '\n'));
484}497}
485498
486test "Reader.readUntilDelimiter returns StreamTooLong, then an empty string" {499test "Reader.readUntilDelimiter returns StreamTooLong, then an empty string" {
487 var buf: [5]u8 = undefined;500 var buf: [5]u8 = undefined;
488 const reader = std.io.fixedBufferStream("12345\n").reader();501 var fis = std.io.fixedBufferStream("12345\n");
502 const reader = fis.reader();
489 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiter(&buf, '\n'));503 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiter(&buf, '\n'));
490 try std.testing.expectEqualStrings("", try reader.readUntilDelimiter(&buf, '\n'));504 try std.testing.expectEqualStrings("", try reader.readUntilDelimiter(&buf, '\n'));
491}505}
492506
493test "Reader.readUntilDelimiter returns StreamTooLong, then bytes read until the delimiter" {507test "Reader.readUntilDelimiter returns StreamTooLong, then bytes read until the delimiter" {
494 var buf: [5]u8 = undefined;508 var buf: [5]u8 = undefined;
495 const reader = std.io.fixedBufferStream("1234567\n").reader();509 var fis = std.io.fixedBufferStream("1234567\n");
510 const reader = fis.reader();
496 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiter(&buf, '\n'));511 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiter(&buf, '\n'));
497 try std.testing.expectEqualStrings("67", try reader.readUntilDelimiter(&buf, '\n'));512 try std.testing.expectEqualStrings("67", try reader.readUntilDelimiter(&buf, '\n'));
498}513}
499514
500test "Reader.readUntilDelimiter returns EndOfStream" {515test "Reader.readUntilDelimiter returns EndOfStream" {
501 var buf: [5]u8 = undefined;516 var buf: [5]u8 = undefined;
502 const reader = std.io.fixedBufferStream("").reader();517 var fis = std.io.fixedBufferStream("");
518 const reader = fis.reader();
503 try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n'));519 try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n'));
504}520}
505521
506test "Reader.readUntilDelimiter returns bytes read until delimiter, then EndOfStream" {522test "Reader.readUntilDelimiter returns bytes read until delimiter, then EndOfStream" {
507 var buf: [5]u8 = undefined;523 var buf: [5]u8 = undefined;
508 const reader = std.io.fixedBufferStream("1234\n").reader();524 var fis = std.io.fixedBufferStream("1234\n");
525 const reader = fis.reader();
509 try std.testing.expectEqualStrings("1234", try reader.readUntilDelimiter(&buf, '\n'));526 try std.testing.expectEqualStrings("1234", try reader.readUntilDelimiter(&buf, '\n'));
510 try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n'));527 try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n'));
511}528}
512529
513test "Reader.readUntilDelimiter returns EndOfStream" {530test "Reader.readUntilDelimiter returns EndOfStream" {
514 var buf: [5]u8 = undefined;531 var buf: [5]u8 = undefined;
515 const reader = std.io.fixedBufferStream("1234").reader();532 var fis = std.io.fixedBufferStream("1234");
533 const reader = fis.reader();
516 try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n'));534 try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n'));
517}535}
518536
519test "Reader.readUntilDelimiter returns StreamTooLong, then EndOfStream" {537test "Reader.readUntilDelimiter returns StreamTooLong, then EndOfStream" {
520 var buf: [5]u8 = undefined;538 var buf: [5]u8 = undefined;
521 const reader = std.io.fixedBufferStream("12345").reader();539 var fis = std.io.fixedBufferStream("12345");
540 const reader = fis.reader();
522 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiter(&buf, '\n'));541 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiter(&buf, '\n'));
523 try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n'));542 try std.testing.expectError(error.EndOfStream, reader.readUntilDelimiter(&buf, '\n'));
524}543}
525544
526test "Reader.readUntilDelimiter writes all bytes read to the output buffer" {545test "Reader.readUntilDelimiter writes all bytes read to the output buffer" {
527 var buf: [5]u8 = undefined;546 var buf: [5]u8 = undefined;
528 const reader = std.io.fixedBufferStream("0000\n12345").reader();547 var fis = std.io.fixedBufferStream("0000\n12345");
548 const reader = fis.reader();
529 _ = try reader.readUntilDelimiter(&buf, '\n');549 _ = try reader.readUntilDelimiter(&buf, '\n');
530 try std.testing.expectEqualStrings("0000\n", &buf);550 try std.testing.expectEqualStrings("0000\n", &buf);
531 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiter(&buf, '\n'));551 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiter(&buf, '\n'));
...@@ -535,7 +555,8 @@ test "Reader.readUntilDelimiter writes all bytes read to the output buffer" {...@@ -535,7 +555,8 @@ test "Reader.readUntilDelimiter writes all bytes read to the output buffer" {
535test "Reader.readUntilDelimiterOrEofAlloc returns ArrayLists with bytes read until the delimiter, then EndOfStream" {555test "Reader.readUntilDelimiterOrEofAlloc returns ArrayLists with bytes read until the delimiter, then EndOfStream" {
536 const a = std.testing.allocator;556 const a = std.testing.allocator;
537557
538 const reader = std.io.fixedBufferStream("0000\n1234\n").reader();558 var fis = std.io.fixedBufferStream("0000\n1234\n");
559 const reader = fis.reader();
539560
540 {561 {
541 var result = (try reader.readUntilDelimiterOrEofAlloc(a, '\n', 5)).?;562 var result = (try reader.readUntilDelimiterOrEofAlloc(a, '\n', 5)).?;
...@@ -555,7 +576,8 @@ test "Reader.readUntilDelimiterOrEofAlloc returns ArrayLists with bytes read unt...@@ -555,7 +576,8 @@ test "Reader.readUntilDelimiterOrEofAlloc returns ArrayLists with bytes read unt
555test "Reader.readUntilDelimiterOrEofAlloc returns an empty ArrayList" {576test "Reader.readUntilDelimiterOrEofAlloc returns an empty ArrayList" {
556 const a = std.testing.allocator;577 const a = std.testing.allocator;
557578
558 const reader = std.io.fixedBufferStream("\n").reader();579 var fis = std.io.fixedBufferStream("\n");
580 const reader = fis.reader();
559581
560 {582 {
561 var result = (try reader.readUntilDelimiterOrEofAlloc(a, '\n', 5)).?;583 var result = (try reader.readUntilDelimiterOrEofAlloc(a, '\n', 5)).?;
...@@ -567,7 +589,8 @@ test "Reader.readUntilDelimiterOrEofAlloc returns an empty ArrayList" {...@@ -567,7 +589,8 @@ test "Reader.readUntilDelimiterOrEofAlloc returns an empty ArrayList" {
567test "Reader.readUntilDelimiterOrEofAlloc returns StreamTooLong, then an ArrayList with bytes read until the delimiter" {589test "Reader.readUntilDelimiterOrEofAlloc returns StreamTooLong, then an ArrayList with bytes read until the delimiter" {
568 const a = std.testing.allocator;590 const a = std.testing.allocator;
569591
570 const reader = std.io.fixedBufferStream("1234567\n").reader();592 var fis = std.io.fixedBufferStream("1234567\n");
593 const reader = fis.reader();
571594
572 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterOrEofAlloc(a, '\n', 5));595 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterOrEofAlloc(a, '\n', 5));
573596
...@@ -578,60 +601,69 @@ test "Reader.readUntilDelimiterOrEofAlloc returns StreamTooLong, then an ArrayLi...@@ -578,60 +601,69 @@ test "Reader.readUntilDelimiterOrEofAlloc returns StreamTooLong, then an ArrayLi
578601
579test "Reader.readUntilDelimiterOrEof returns bytes read until the delimiter" {602test "Reader.readUntilDelimiterOrEof returns bytes read until the delimiter" {
580 var buf: [5]u8 = undefined;603 var buf: [5]u8 = undefined;
581 const reader = std.io.fixedBufferStream("0000\n1234\n").reader();604 var fis = std.io.fixedBufferStream("0000\n1234\n");
605 const reader = fis.reader();
582 try std.testing.expectEqualStrings("0000", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);606 try std.testing.expectEqualStrings("0000", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);
583 try std.testing.expectEqualStrings("1234", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);607 try std.testing.expectEqualStrings("1234", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);
584}608}
585609
586test "Reader.readUntilDelimiterOrEof returns an empty string" {610test "Reader.readUntilDelimiterOrEof returns an empty string" {
587 var buf: [5]u8 = undefined;611 var buf: [5]u8 = undefined;
588 const reader = std.io.fixedBufferStream("\n").reader();612 var fis = std.io.fixedBufferStream("\n");
613 const reader = fis.reader();
589 try std.testing.expectEqualStrings("", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);614 try std.testing.expectEqualStrings("", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);
590}615}
591616
592test "Reader.readUntilDelimiterOrEof returns StreamTooLong, then an empty string" {617test "Reader.readUntilDelimiterOrEof returns StreamTooLong, then an empty string" {
593 var buf: [5]u8 = undefined;618 var buf: [5]u8 = undefined;
594 const reader = std.io.fixedBufferStream("12345\n").reader();619 var fis = std.io.fixedBufferStream("12345\n");
620 const reader = fis.reader();
595 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterOrEof(&buf, '\n'));621 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterOrEof(&buf, '\n'));
596 try std.testing.expectEqualStrings("", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);622 try std.testing.expectEqualStrings("", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);
597}623}
598624
599test "Reader.readUntilDelimiterOrEof returns StreamTooLong, then bytes read until the delimiter" {625test "Reader.readUntilDelimiterOrEof returns StreamTooLong, then bytes read until the delimiter" {
600 var buf: [5]u8 = undefined;626 var buf: [5]u8 = undefined;
601 const reader = std.io.fixedBufferStream("1234567\n").reader();627 var fis = std.io.fixedBufferStream("1234567\n");
628 const reader = fis.reader();
602 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterOrEof(&buf, '\n'));629 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterOrEof(&buf, '\n'));
603 try std.testing.expectEqualStrings("67", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);630 try std.testing.expectEqualStrings("67", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);
604}631}
605632
606test "Reader.readUntilDelimiterOrEof returns null" {633test "Reader.readUntilDelimiterOrEof returns null" {
607 var buf: [5]u8 = undefined;634 var buf: [5]u8 = undefined;
608 const reader = std.io.fixedBufferStream("").reader();635 var fis = std.io.fixedBufferStream("");
636 const reader = fis.reader();
609 try std.testing.expect((try reader.readUntilDelimiterOrEof(&buf, '\n')) == null);637 try std.testing.expect((try reader.readUntilDelimiterOrEof(&buf, '\n')) == null);
610}638}
611639
612test "Reader.readUntilDelimiterOrEof returns bytes read until delimiter, then null" {640test "Reader.readUntilDelimiterOrEof returns bytes read until delimiter, then null" {
613 var buf: [5]u8 = undefined;641 var buf: [5]u8 = undefined;
614 const reader = std.io.fixedBufferStream("1234\n").reader();642 var fis = std.io.fixedBufferStream("1234\n");
643 const reader = fis.reader();
615 try std.testing.expectEqualStrings("1234", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);644 try std.testing.expectEqualStrings("1234", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);
616 try std.testing.expect((try reader.readUntilDelimiterOrEof(&buf, '\n')) == null);645 try std.testing.expect((try reader.readUntilDelimiterOrEof(&buf, '\n')) == null);
617}646}
618647
619test "Reader.readUntilDelimiterOrEof returns bytes read until end-of-stream" {648test "Reader.readUntilDelimiterOrEof returns bytes read until end-of-stream" {
620 var buf: [5]u8 = undefined;649 var buf: [5]u8 = undefined;
621 const reader = std.io.fixedBufferStream("1234").reader();650 var fis = std.io.fixedBufferStream("1234");
651 const reader = fis.reader();
622 try std.testing.expectEqualStrings("1234", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);652 try std.testing.expectEqualStrings("1234", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);
623}653}
624654
625test "Reader.readUntilDelimiterOrEof returns StreamTooLong, then bytes read until end-of-stream" {655test "Reader.readUntilDelimiterOrEof returns StreamTooLong, then bytes read until end-of-stream" {
626 var buf: [5]u8 = undefined;656 var buf: [5]u8 = undefined;
627 const reader = std.io.fixedBufferStream("1234567").reader();657 var fis = std.io.fixedBufferStream("1234567");
658 const reader = fis.reader();
628 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterOrEof(&buf, '\n'));659 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterOrEof(&buf, '\n'));
629 try std.testing.expectEqualStrings("67", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);660 try std.testing.expectEqualStrings("67", (try reader.readUntilDelimiterOrEof(&buf, '\n')).?);
630}661}
631662
632test "Reader.readUntilDelimiterOrEof writes all bytes read to the output buffer" {663test "Reader.readUntilDelimiterOrEof writes all bytes read to the output buffer" {
633 var buf: [5]u8 = undefined;664 var buf: [5]u8 = undefined;
634 const reader = std.io.fixedBufferStream("0000\n12345").reader();665 var fis = std.io.fixedBufferStream("0000\n12345");
666 const reader = fis.reader();
635 _ = try reader.readUntilDelimiterOrEof(&buf, '\n');667 _ = try reader.readUntilDelimiterOrEof(&buf, '\n');
636 try std.testing.expectEqualStrings("0000\n", &buf);668 try std.testing.expectEqualStrings("0000\n", &buf);
637 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterOrEof(&buf, '\n'));669 try std.testing.expectError(error.StreamTooLong, reader.readUntilDelimiterOrEof(&buf, '\n'));
lib/std/json.zig+136-85
...@@ -1506,42 +1506,46 @@ fn skipValue(tokens: *TokenStream) SkipValueError!void {...@@ -1506,42 +1506,46 @@ fn skipValue(tokens: *TokenStream) SkipValueError!void {
1506}1506}
15071507
1508test "skipValue" {1508test "skipValue" {
1509 try skipValue(&TokenStream.init("false"));1509 var ts = TokenStream.init("false");
1510 try skipValue(&TokenStream.init("true"));1510 try skipValue(&ts);
1511 try skipValue(&TokenStream.init("null"));1511 ts = TokenStream.init("true");
1512 try skipValue(&TokenStream.init("42"));1512 try skipValue(&ts);
1513 try skipValue(&TokenStream.init("42.0"));1513 ts = TokenStream.init("null");
1514 try skipValue(&TokenStream.init("\"foo\""));1514 try skipValue(&ts);
1515 try skipValue(&TokenStream.init("[101, 111, 121]"));1515 ts = TokenStream.init("42");
1516 try skipValue(&TokenStream.init("{}"));1516 try skipValue(&ts);
1517 try skipValue(&TokenStream.init("{\"foo\": \"bar\"}"));1517 ts = TokenStream.init("42.0");
1518 try skipValue(&ts);
1519 ts = TokenStream.init("\"foo\"");
1520 try skipValue(&ts);
1521 ts = TokenStream.init("[101, 111, 121]");
1522 try skipValue(&ts);
1523 ts = TokenStream.init("{}");
1524 try skipValue(&ts);
1525 ts = TokenStream.init("{\"foo\": \"bar\"}");
1526 try skipValue(&ts);
15181527
1519 { // An absurd number of nestings1528 { // An absurd number of nestings
1520 const nestings = StreamingParser.default_max_nestings + 1;1529 const nestings = StreamingParser.default_max_nestings + 1;
15211530
1522 try testing.expectError(1531 ts = TokenStream.init("[" ** nestings ++ "]" ** nestings);
1523 error.TooManyNestedItems,1532 try testing.expectError(error.TooManyNestedItems, skipValue(&ts));
1524 skipValue(&TokenStream.init("[" ** nestings ++ "]" ** nestings)),
1525 );
1526 }1533 }
15271534
1528 { // Would a number token cause problems in a deeply-nested array?1535 { // Would a number token cause problems in a deeply-nested array?
1529 const nestings = StreamingParser.default_max_nestings;1536 const nestings = StreamingParser.default_max_nestings;
1530 const deeply_nested_array = "[" ** nestings ++ "0.118, 999, 881.99, 911.9, 725, 3" ++ "]" ** nestings;1537 const deeply_nested_array = "[" ** nestings ++ "0.118, 999, 881.99, 911.9, 725, 3" ++ "]" ** nestings;
15311538
1532 try skipValue(&TokenStream.init(deeply_nested_array));1539 ts = TokenStream.init(deeply_nested_array);
1540 try skipValue(&ts);
15331541
1534 try testing.expectError(1542 ts = TokenStream.init("[" ++ deeply_nested_array ++ "]");
1535 error.TooManyNestedItems,1543 try testing.expectError(error.TooManyNestedItems, skipValue(&ts));
1536 skipValue(&TokenStream.init("[" ++ deeply_nested_array ++ "]")),
1537 );
1538 }1544 }
15391545
1540 // Mismatched brace/square bracket1546 // Mismatched brace/square bracket
1541 try testing.expectError(1547 ts = TokenStream.init("[102, 111, 111}");
1542 error.UnexpectedClosingBrace,1548 try testing.expectError(error.UnexpectedClosingBrace, skipValue(&ts));
1543 skipValue(&TokenStream.init("[102, 111, 111}")),
1544 );
15451549
1546 { // should fail if no value found (e.g. immediate close of object)1550 { // should fail if no value found (e.g. immediate close of object)
1547 var empty_object = TokenStream.init("{}");1551 var empty_object = TokenStream.init("{}");
...@@ -1980,18 +1984,29 @@ pub fn parseFree(comptime T: type, value: T, options: ParseOptions) void {...@@ -1980,18 +1984,29 @@ pub fn parseFree(comptime T: type, value: T, options: ParseOptions) void {
1980}1984}
19811985
1982test "parse" {1986test "parse" {
1983 try testing.expectEqual(false, try parse(bool, &TokenStream.init("false"), ParseOptions{}));1987 var ts = TokenStream.init("false");
1984 try testing.expectEqual(true, try parse(bool, &TokenStream.init("true"), ParseOptions{}));1988 try testing.expectEqual(false, try parse(bool, &ts, ParseOptions{}));
1985 try testing.expectEqual(@as(u1, 1), try parse(u1, &TokenStream.init("1"), ParseOptions{}));1989 ts = TokenStream.init("true");
1986 try testing.expectError(error.Overflow, parse(u1, &TokenStream.init("50"), ParseOptions{}));1990 try testing.expectEqual(true, try parse(bool, &ts, ParseOptions{}));
1987 try testing.expectEqual(@as(u64, 42), try parse(u64, &TokenStream.init("42"), ParseOptions{}));1991 ts = TokenStream.init("1");
1988 try testing.expectEqual(@as(f64, 42), try parse(f64, &TokenStream.init("42.0"), ParseOptions{}));1992 try testing.expectEqual(@as(u1, 1), try parse(u1, &ts, ParseOptions{}));
1989 try testing.expectEqual(@as(?bool, null), try parse(?bool, &TokenStream.init("null"), ParseOptions{}));1993 ts = TokenStream.init("50");
1990 try testing.expectEqual(@as(?bool, true), try parse(?bool, &TokenStream.init("true"), ParseOptions{}));1994 try testing.expectError(error.Overflow, parse(u1, &ts, ParseOptions{}));
19911995 ts = TokenStream.init("42");
1992 try testing.expectEqual(@as([3]u8, "foo".*), try parse([3]u8, &TokenStream.init("\"foo\""), ParseOptions{}));1996 try testing.expectEqual(@as(u64, 42), try parse(u64, &ts, ParseOptions{}));
1993 try testing.expectEqual(@as([3]u8, "foo".*), try parse([3]u8, &TokenStream.init("[102, 111, 111]"), ParseOptions{}));1997 ts = TokenStream.init("42.0");
1994 try testing.expectEqual(@as([0]u8, undefined), try parse([0]u8, &TokenStream.init("[]"), ParseOptions{}));1998 try testing.expectEqual(@as(f64, 42), try parse(f64, &ts, ParseOptions{}));
1999 ts = TokenStream.init("null");
2000 try testing.expectEqual(@as(?bool, null), try parse(?bool, &ts, ParseOptions{}));
2001 ts = TokenStream.init("true");
2002 try testing.expectEqual(@as(?bool, true), try parse(?bool, &ts, ParseOptions{}));
2003
2004 ts = TokenStream.init("\"foo\"");
2005 try testing.expectEqual(@as([3]u8, "foo".*), try parse([3]u8, &ts, ParseOptions{}));
2006 ts = TokenStream.init("[102, 111, 111]");
2007 try testing.expectEqual(@as([3]u8, "foo".*), try parse([3]u8, &ts, ParseOptions{}));
2008 ts = TokenStream.init("[]");
2009 try testing.expectEqual(@as([0]u8, undefined), try parse([0]u8, &ts, ParseOptions{}));
1995}2010}
19962011
1997test "parse into enum" {2012test "parse into enum" {
...@@ -2000,36 +2015,48 @@ test "parse into enum" {...@@ -2000,36 +2015,48 @@ test "parse into enum" {
2000 Bar,2015 Bar,
2001 @"with\\escape",2016 @"with\\escape",
2002 };2017 };
2003 try testing.expectEqual(@as(T, .Foo), try parse(T, &TokenStream.init("\"Foo\""), ParseOptions{}));2018 var ts = TokenStream.init("\"Foo\"");
2004 try testing.expectEqual(@as(T, .Foo), try parse(T, &TokenStream.init("42"), ParseOptions{}));2019 try testing.expectEqual(@as(T, .Foo), try parse(T, &ts, ParseOptions{}));
2005 try testing.expectEqual(@as(T, .@"with\\escape"), try parse(T, &TokenStream.init("\"with\\\\escape\""), ParseOptions{}));2020 ts = TokenStream.init("42");
2006 try testing.expectError(error.InvalidEnumTag, parse(T, &TokenStream.init("5"), ParseOptions{}));2021 try testing.expectEqual(@as(T, .Foo), try parse(T, &ts, ParseOptions{}));
2007 try testing.expectError(error.InvalidEnumTag, parse(T, &TokenStream.init("\"Qux\""), ParseOptions{}));2022 ts = TokenStream.init("\"with\\\\escape\"");
2023 try testing.expectEqual(@as(T, .@"with\\escape"), try parse(T, &ts, ParseOptions{}));
2024 ts = TokenStream.init("5");
2025 try testing.expectError(error.InvalidEnumTag, parse(T, &ts, ParseOptions{}));
2026 ts = TokenStream.init("\"Qux\"");
2027 try testing.expectError(error.InvalidEnumTag, parse(T, &ts, ParseOptions{}));
2008}2028}
20092029
2010test "parse with trailing data" {2030test "parse with trailing data" {
2011 try testing.expectEqual(false, try parse(bool, &TokenStream.init("falsed"), ParseOptions{ .allow_trailing_data = true }));2031 var ts = TokenStream.init("falsed");
2012 try testing.expectError(error.InvalidTopLevelTrailing, parse(bool, &TokenStream.init("falsed"), ParseOptions{ .allow_trailing_data = false }));2032 try testing.expectEqual(false, try parse(bool, &ts, ParseOptions{ .allow_trailing_data = true }));
2033 ts = TokenStream.init("falsed");
2034 try testing.expectError(error.InvalidTopLevelTrailing, parse(bool, &ts, ParseOptions{ .allow_trailing_data = false }));
2013 // trailing whitespace is okay2035 // trailing whitespace is okay
2014 try testing.expectEqual(false, try parse(bool, &TokenStream.init("false \n"), ParseOptions{ .allow_trailing_data = false }));2036 ts = TokenStream.init("false \n");
2037 try testing.expectEqual(false, try parse(bool, &ts, ParseOptions{ .allow_trailing_data = false }));
2015}2038}
20162039
2017test "parse into that allocates a slice" {2040test "parse into that allocates a slice" {
2018 try testing.expectError(error.AllocatorRequired, parse([]u8, &TokenStream.init("\"foo\""), ParseOptions{}));2041 var ts = TokenStream.init("\"foo\"");
2042 try testing.expectError(error.AllocatorRequired, parse([]u8, &ts, ParseOptions{}));
20192043
2020 const options = ParseOptions{ .allocator = testing.allocator };2044 const options = ParseOptions{ .allocator = testing.allocator };
2021 {2045 {
2022 const r = try parse([]u8, &TokenStream.init("\"foo\""), options);2046 ts = TokenStream.init("\"foo\"");
2047 const r = try parse([]u8, &ts, options);
2023 defer parseFree([]u8, r, options);2048 defer parseFree([]u8, r, options);
2024 try testing.expectEqualSlices(u8, "foo", r);2049 try testing.expectEqualSlices(u8, "foo", r);
2025 }2050 }
2026 {2051 {
2027 const r = try parse([]u8, &TokenStream.init("[102, 111, 111]"), options);2052 ts = TokenStream.init("[102, 111, 111]");
2053 const r = try parse([]u8, &ts, options);
2028 defer parseFree([]u8, r, options);2054 defer parseFree([]u8, r, options);
2029 try testing.expectEqualSlices(u8, "foo", r);2055 try testing.expectEqualSlices(u8, "foo", r);
2030 }2056 }
2031 {2057 {
2032 const r = try parse([]u8, &TokenStream.init("\"with\\\\escape\""), options);2058 ts = TokenStream.init("\"with\\\\escape\"");
2059 const r = try parse([]u8, &ts, options);
2033 defer parseFree([]u8, r, options);2060 defer parseFree([]u8, r, options);
2034 try testing.expectEqualSlices(u8, "with\\escape", r);2061 try testing.expectEqualSlices(u8, "with\\escape", r);
2035 }2062 }
...@@ -2042,7 +2069,8 @@ test "parse into tagged union" {...@@ -2042,7 +2069,8 @@ test "parse into tagged union" {
2042 float: f64,2069 float: f64,
2043 string: []const u8,2070 string: []const u8,
2044 };2071 };
2045 try testing.expectEqual(T{ .float = 1.5 }, try parse(T, &TokenStream.init("1.5"), ParseOptions{}));2072 var ts = TokenStream.init("1.5");
2073 try testing.expectEqual(T{ .float = 1.5 }, try parse(T, &ts, ParseOptions{}));
2046 }2074 }
20472075
2048 { // failing allocations should be bubbled up instantly without trying next member2076 { // failing allocations should be bubbled up instantly without trying next member
...@@ -2053,7 +2081,8 @@ test "parse into tagged union" {...@@ -2053,7 +2081,8 @@ test "parse into tagged union" {
2053 string: []const u8,2081 string: []const u8,
2054 array: [3]u8,2082 array: [3]u8,
2055 };2083 };
2056 try testing.expectError(error.OutOfMemory, parse(T, &TokenStream.init("[1,2,3]"), options));2084 var ts = TokenStream.init("[1,2,3]");
2085 try testing.expectError(error.OutOfMemory, parse(T, &ts, options));
2057 }2086 }
20582087
2059 {2088 {
...@@ -2062,7 +2091,8 @@ test "parse into tagged union" {...@@ -2062,7 +2091,8 @@ test "parse into tagged union" {
2062 x: u8,2091 x: u8,
2063 y: u8,2092 y: u8,
2064 };2093 };
2065 try testing.expectEqual(T{ .x = 42 }, try parse(T, &TokenStream.init("42"), ParseOptions{}));2094 var ts = TokenStream.init("42");
2095 try testing.expectEqual(T{ .x = 42 }, try parse(T, &ts, ParseOptions{}));
2066 }2096 }
20672097
2068 { // needs to back out when first union member doesn't match2098 { // needs to back out when first union member doesn't match
...@@ -2070,7 +2100,8 @@ test "parse into tagged union" {...@@ -2070,7 +2100,8 @@ test "parse into tagged union" {
2070 A: struct { x: u32 },2100 A: struct { x: u32 },
2071 B: struct { y: u32 },2101 B: struct { y: u32 },
2072 };2102 };
2073 try testing.expectEqual(T{ .B = .{ .y = 42 } }, try parse(T, &TokenStream.init("{\"y\":42}"), ParseOptions{}));2103 var ts = TokenStream.init("{\"y\":42}");
2104 try testing.expectEqual(T{ .B = .{ .y = 42 } }, try parse(T, &ts, ParseOptions{}));
2074 }2105 }
2075}2106}
20762107
...@@ -2080,7 +2111,8 @@ test "parse union bubbles up AllocatorRequired" {...@@ -2080,7 +2111,8 @@ test "parse union bubbles up AllocatorRequired" {
2080 string: []const u8,2111 string: []const u8,
2081 int: i32,2112 int: i32,
2082 };2113 };
2083 try testing.expectError(error.AllocatorRequired, parse(T, &TokenStream.init("42"), ParseOptions{}));2114 var ts = TokenStream.init("42");
2115 try testing.expectError(error.AllocatorRequired, parse(T, &ts, ParseOptions{}));
2084 }2116 }
20852117
2086 { // string member not first in union (and matching)2118 { // string member not first in union (and matching)
...@@ -2089,7 +2121,8 @@ test "parse union bubbles up AllocatorRequired" {...@@ -2089,7 +2121,8 @@ test "parse union bubbles up AllocatorRequired" {
2089 float: f64,2121 float: f64,
2090 string: []const u8,2122 string: []const u8,
2091 };2123 };
2092 try testing.expectError(error.AllocatorRequired, parse(T, &TokenStream.init("\"foo\""), ParseOptions{}));2124 var ts = TokenStream.init("\"foo\"");
2125 try testing.expectError(error.AllocatorRequired, parse(T, &ts, ParseOptions{}));
2093 }2126 }
2094}2127}
20952128
...@@ -2102,7 +2135,8 @@ test "parseFree descends into tagged union" {...@@ -2102,7 +2135,8 @@ test "parseFree descends into tagged union" {
2102 string: []const u8,2135 string: []const u8,
2103 };2136 };
2104 // use a string with unicode escape so we know result can't be a reference to global constant2137 // use a string with unicode escape so we know result can't be a reference to global constant
2105 const r = try parse(T, &TokenStream.init("\"with\\u0105unicode\""), options);2138 var ts = TokenStream.init("\"with\\u0105unicode\"");
2139 const r = try parse(T, &ts, options);
2106 try testing.expectEqual(std.meta.Tag(T).string, @as(std.meta.Tag(T), r));2140 try testing.expectEqual(std.meta.Tag(T).string, @as(std.meta.Tag(T), r));
2107 try testing.expectEqualSlices(u8, "withąunicode", r.string);2141 try testing.expectEqualSlices(u8, "withąunicode", r.string);
2108 try testing.expectEqual(@as(usize, 0), fail_alloc.deallocations);2142 try testing.expectEqual(@as(usize, 0), fail_alloc.deallocations);
...@@ -2116,12 +2150,13 @@ test "parse with comptime field" {...@@ -2116,12 +2150,13 @@ test "parse with comptime field" {
2116 comptime a: i32 = 0,2150 comptime a: i32 = 0,
2117 b: bool,2151 b: bool,
2118 };2152 };
2119 try testing.expectEqual(T{ .a = 0, .b = true }, try parse(T, &TokenStream.init(2153 var ts = TokenStream.init(
2120 \\{2154 \\{
2121 \\ "a": 0,2155 \\ "a": 0,
2122 \\ "b": true2156 \\ "b": true
2123 \\}2157 \\}
2124 ), ParseOptions{}));2158 );
2159 try testing.expectEqual(T{ .a = 0, .b = true }, try parse(T, &ts, ParseOptions{}));
2125 }2160 }
21262161
2127 { // string comptime values currently require an allocator2162 { // string comptime values currently require an allocator
...@@ -2140,12 +2175,13 @@ test "parse with comptime field" {...@@ -2140,12 +2175,13 @@ test "parse with comptime field" {
2140 .allocator = std.testing.allocator,2175 .allocator = std.testing.allocator,
2141 };2176 };
21422177
2143 const r = try parse(T, &TokenStream.init(2178 var ts = TokenStream.init(
2144 \\{2179 \\{
2145 \\ "kind": "float",2180 \\ "kind": "float",
2146 \\ "b": 1.02181 \\ "b": 1.0
2147 \\}2182 \\}
2148 ), options);2183 );
2184 const r = try parse(T, &ts, options);
21492185
2150 // check that parseFree doesn't try to free comptime fields2186 // check that parseFree doesn't try to free comptime fields
2151 parseFree(T, r, options);2187 parseFree(T, r, options);
...@@ -2154,7 +2190,8 @@ test "parse with comptime field" {...@@ -2154,7 +2190,8 @@ test "parse with comptime field" {
21542190
2155test "parse into struct with no fields" {2191test "parse into struct with no fields" {
2156 const T = struct {};2192 const T = struct {};
2157 try testing.expectEqual(T{}, try parse(T, &TokenStream.init("{}"), ParseOptions{}));2193 var ts = TokenStream.init("{}");
2194 try testing.expectEqual(T{}, try parse(T, &ts, ParseOptions{}));
2158}2195}
21592196
2160test "parse into struct with misc fields" {2197test "parse into struct with misc fields" {
...@@ -2186,7 +2223,7 @@ test "parse into struct with misc fields" {...@@ -2186,7 +2223,7 @@ test "parse into struct with misc fields" {
2186 string: []const u8,2223 string: []const u8,
2187 };2224 };
2188 };2225 };
2189 const r = try parse(T, &TokenStream.init(2226 var ts = TokenStream.init(
2190 \\{2227 \\{
2191 \\ "int": 420,2228 \\ "int": 420,
2192 \\ "float": 3.14,2229 \\ "float": 3.14,
...@@ -2208,7 +2245,8 @@ test "parse into struct with misc fields" {...@@ -2208,7 +2245,8 @@ test "parse into struct with misc fields" {
2208 \\ ],2245 \\ ],
2209 \\ "a_union": 1000002246 \\ "a_union": 100000
2210 \\}2247 \\}
2211 ), options);2248 );
2249 const r = try parse(T, &ts, options);
2212 defer parseFree(T, r, options);2250 defer parseFree(T, r, options);
2213 try testing.expectEqual(@as(i64, 420), r.int);2251 try testing.expectEqual(@as(i64, 420), r.int);
2214 try testing.expectEqual(@as(f64, 3.14), r.float);2252 try testing.expectEqual(@as(f64, 3.14), r.float);
...@@ -2239,14 +2277,15 @@ test "parse into struct with strings and arrays with sentinels" {...@@ -2239,14 +2277,15 @@ test "parse into struct with strings and arrays with sentinels" {
2239 data: [:99]const i32,2277 data: [:99]const i32,
2240 simple_data: []const i32,2278 simple_data: []const i32,
2241 };2279 };
2242 const r = try parse(T, &TokenStream.init(2280 var ts = TokenStream.init(
2243 \\{2281 \\{
2244 \\ "language": "zig",2282 \\ "language": "zig",
2245 \\ "language_without_sentinel": "zig again!",2283 \\ "language_without_sentinel": "zig again!",
2246 \\ "data": [1, 2, 3],2284 \\ "data": [1, 2, 3],
2247 \\ "simple_data": [4, 5, 6]2285 \\ "simple_data": [4, 5, 6]
2248 \\}2286 \\}
2249 ), options);2287 );
2288 const r = try parse(T, &ts, options);
2250 defer parseFree(T, r, options);2289 defer parseFree(T, r, options);
22512290
2252 try testing.expectEqualSentinel(u8, 0, "zig", r.language);2291 try testing.expectEqualSentinel(u8, 0, "zig", r.language);
...@@ -2275,19 +2314,25 @@ test "parse into struct with duplicate field" {...@@ -2275,19 +2314,25 @@ test "parse into struct with duplicate field" {
22752314
2276 const T1 = struct { a: *u64 };2315 const T1 = struct { a: *u64 };
2277 // both .UseFirst and .UseLast should fail because second "a" value isn't a u642316 // both .UseFirst and .UseLast should fail because second "a" value isn't a u64
2278 try testing.expectError(error.InvalidNumber, parse(T1, &TokenStream.init(str), options_first));2317 var ts = TokenStream.init(str);
2279 try testing.expectError(error.InvalidNumber, parse(T1, &TokenStream.init(str), options_last));2318 try testing.expectError(error.InvalidNumber, parse(T1, &ts, options_first));
2319 ts = TokenStream.init(str);
2320 try testing.expectError(error.InvalidNumber, parse(T1, &ts, options_last));
22802321
2281 const T2 = struct { a: f64 };2322 const T2 = struct { a: f64 };
2282 try testing.expectEqual(T2{ .a = 1.0 }, try parse(T2, &TokenStream.init(str), options_first));2323 ts = TokenStream.init(str);
2283 try testing.expectEqual(T2{ .a = 0.25 }, try parse(T2, &TokenStream.init(str), options_last));2324 try testing.expectEqual(T2{ .a = 1.0 }, try parse(T2, &ts, options_first));
2325 ts = TokenStream.init(str);
2326 try testing.expectEqual(T2{ .a = 0.25 }, try parse(T2, &ts, options_last));
22842327
2285 const T3 = struct { comptime a: f64 = 1.0 };2328 const T3 = struct { comptime a: f64 = 1.0 };
2286 // .UseFirst should succeed because second "a" value is unconditionally ignored (even though != 1.0)2329 // .UseFirst should succeed because second "a" value is unconditionally ignored (even though != 1.0)
2287 const t3 = T3{ .a = 1.0 };2330 const t3 = T3{ .a = 1.0 };
2288 try testing.expectEqual(t3, try parse(T3, &TokenStream.init(str), options_first));2331 ts = TokenStream.init(str);
2332 try testing.expectEqual(t3, try parse(T3, &ts, options_first));
2289 // .UseLast should fail because second "a" value is 0.25 which is not equal to default value of 1.02333 // .UseLast should fail because second "a" value is 0.25 which is not equal to default value of 1.0
2290 try testing.expectError(error.UnexpectedValue, parse(T3, &TokenStream.init(str), options_last));2334 ts = TokenStream.init(str);
2335 try testing.expectError(error.UnexpectedValue, parse(T3, &ts, options_last));
2291}2336}
22922337
2293test "parse into struct ignoring unknown fields" {2338test "parse into struct ignoring unknown fields" {
...@@ -2301,7 +2346,7 @@ test "parse into struct ignoring unknown fields" {...@@ -2301,7 +2346,7 @@ test "parse into struct ignoring unknown fields" {
2301 .ignore_unknown_fields = true,2346 .ignore_unknown_fields = true,
2302 };2347 };
23032348
2304 const r = try parse(T, &std.json.TokenStream.init(2349 var ts = TokenStream.init(
2305 \\{2350 \\{
2306 \\ "int": 420,2351 \\ "int": 420,
2307 \\ "float": 3.14,2352 \\ "float": 3.14,
...@@ -2323,7 +2368,8 @@ test "parse into struct ignoring unknown fields" {...@@ -2323,7 +2368,8 @@ test "parse into struct ignoring unknown fields" {
2323 \\ "a_union": 100000,2368 \\ "a_union": 100000,
2324 \\ "language": "zig"2369 \\ "language": "zig"
2325 \\}2370 \\}
2326 ), ops);2371 );
2372 const r = try parse(T, &ts, ops);
2327 defer parseFree(T, r, ops);2373 defer parseFree(T, r, ops);
23282374
2329 try testing.expectEqual(@as(i64, 420), r.int);2375 try testing.expectEqual(@as(i64, 420), r.int);
...@@ -2341,7 +2387,8 @@ test "parse into recursive union definition" {...@@ -2341,7 +2387,8 @@ test "parse into recursive union definition" {
2341 };2387 };
2342 const ops = ParseOptions{ .allocator = testing.allocator };2388 const ops = ParseOptions{ .allocator = testing.allocator };
23432389
2344 const r = try parse(T, &std.json.TokenStream.init("{\"values\":[58]}"), ops);2390 var ts = TokenStream.init("{\"values\":[58]}");
2391 const r = try parse(T, &ts, ops);
2345 defer parseFree(T, r, ops);2392 defer parseFree(T, r, ops);
23462393
2347 try testing.expectEqual(@as(i64, 58), r.values.array[0].integer);2394 try testing.expectEqual(@as(i64, 58), r.values.array[0].integer);
...@@ -2363,7 +2410,8 @@ test "parse into double recursive union definition" {...@@ -2363,7 +2410,8 @@ test "parse into double recursive union definition" {
2363 };2410 };
2364 const ops = ParseOptions{ .allocator = testing.allocator };2411 const ops = ParseOptions{ .allocator = testing.allocator };
23652412
2366 const r = try parse(T, &std.json.TokenStream.init("{\"values\":[[58]]}"), ops);2413 var ts = TokenStream.init("{\"values\":[[58]]}");
2414 const r = try parse(T, &ts, ops);
2367 defer parseFree(T, r, ops);2415 defer parseFree(T, r, ops);
23682416
2369 try testing.expectEqual(@as(i64, 58), r.values.array[0].array[0].integer);2417 try testing.expectEqual(@as(i64, 58), r.values.array[0].array[0].integer);
...@@ -2806,10 +2854,13 @@ test "integer after float has proper type" {...@@ -2806,10 +2854,13 @@ test "integer after float has proper type" {
28062854
2807test "parse exponential into int" {2855test "parse exponential into int" {
2808 const T = struct { int: i64 };2856 const T = struct { int: i64 };
2809 const r = try parse(T, &TokenStream.init("{ \"int\": 4.2e2 }"), ParseOptions{});2857 var ts = TokenStream.init("{ \"int\": 4.2e2 }");
2858 const r = try parse(T, &ts, ParseOptions{});
2810 try testing.expectEqual(@as(i64, 420), r.int);2859 try testing.expectEqual(@as(i64, 420), r.int);
2811 try testing.expectError(error.InvalidNumber, parse(T, &TokenStream.init("{ \"int\": 0.042e2 }"), ParseOptions{}));2860 ts = TokenStream.init("{ \"int\": 0.042e2 }");
2812 try testing.expectError(error.Overflow, parse(T, &TokenStream.init("{ \"int\": 18446744073709551616.0 }"), ParseOptions{}));2861 try testing.expectError(error.InvalidNumber, parse(T, &ts, ParseOptions{}));
2862 ts = TokenStream.init("{ \"int\": 18446744073709551616.0 }");
2863 try testing.expectError(error.Overflow, parse(T, &ts, ParseOptions{}));
2813}2864}
28142865
2815test "escaped characters" {2866test "escaped characters" {
...@@ -2858,10 +2909,12 @@ test "string copy option" {...@@ -2858,10 +2909,12 @@ test "string copy option" {
2858 defer arena_allocator.deinit();2909 defer arena_allocator.deinit();
2859 const allocator = arena_allocator.allocator();2910 const allocator = arena_allocator.allocator();
28602911
2861 const tree_nocopy = try Parser.init(allocator, false).parse(input);2912 var parser = Parser.init(allocator, false);
2913 const tree_nocopy = try parser.parse(input);
2862 const obj_nocopy = tree_nocopy.root.Object;2914 const obj_nocopy = tree_nocopy.root.Object;
28632915
2864 const tree_copy = try Parser.init(allocator, true).parse(input);2916 parser = Parser.init(allocator, true);
2917 const tree_copy = try parser.parse(input);
2865 const obj_copy = tree_copy.root.Object;2918 const obj_copy = tree_copy.root.Object;
28662919
2867 for ([_][]const u8{ "noescape", "simple", "unicode", "surrogatepair" }) |field_name| {2920 for ([_][]const u8{ "noescape", "simple", "unicode", "surrogatepair" }) |field_name| {
...@@ -3376,14 +3429,12 @@ test "stringify null optional fields" {...@@ -3376,14 +3429,12 @@ test "stringify null optional fields" {
3376 StringifyOptions{ .emit_null_optional_fields = false },3429 StringifyOptions{ .emit_null_optional_fields = false },
3377 );3430 );
33783431
3379 try std.testing.expect(try parsesTo(3432 var ts = TokenStream.init(
3380 MyStruct,3433 \\{"required":"something","another_required":"something else"}
3381 MyStruct{},3434 );
3382 &TokenStream.init(3435 try std.testing.expect(try parsesTo(MyStruct, MyStruct{}, &ts, .{
3383 \\{"required":"something","another_required":"something else"}3436 .allocator = std.testing.allocator,
3384 ),3437 }));
3385 .{ .allocator = std.testing.allocator },
3386 ));
3387}3438}
33883439
3389// Same as `stringify` but accepts an Allocator and stores result in dynamically allocated memory instead of using a Writer.3440// Same as `stringify` but accepts an Allocator and stores result in dynamically allocated memory instead of using a Writer.
lib/std/meta.zig+4-1
...@@ -311,7 +311,10 @@ pub fn assumeSentinel(p: anytype, comptime sentinel_val: Elem(@TypeOf(p))) Senti...@@ -311,7 +311,10 @@ pub fn assumeSentinel(p: anytype, comptime sentinel_val: Elem(@TypeOf(p))) Senti
311 const ReturnType = Sentinel(T, sentinel_val);311 const ReturnType = Sentinel(T, sentinel_val);
312 switch (@typeInfo(T)) {312 switch (@typeInfo(T)) {
313 .Pointer => |info| switch (info.size) {313 .Pointer => |info| switch (info.size) {
314 .Slice => return @bitCast(ReturnType, p),314 .Slice => if (@import("builtin").zig_backend == .stage1)
315 return @bitCast(ReturnType, p)
316 else
317 return @ptrCast(ReturnType, p),
315 .Many, .One => return @ptrCast(ReturnType, p),318 .Many, .One => return @ptrCast(ReturnType, p),
316 .C => {},319 .C => {},
317 },320 },
lib/std/net.zig+7-5
...@@ -1141,18 +1141,20 @@ fn linuxLookupNameFromHosts(...@@ -1141,18 +1141,20 @@ fn linuxLookupNameFromHosts(
1141 };1141 };
1142 defer file.close();1142 defer file.close();
11431143
1144 const stream = std.io.bufferedReader(file.reader()).reader();1144 var buffered_reader = std.io.bufferedReader(file.reader());
1145 const reader = buffered_reader.reader();
1145 var line_buf: [512]u8 = undefined;1146 var line_buf: [512]u8 = undefined;
1146 while (stream.readUntilDelimiterOrEof(&line_buf, '\n') catch |err| switch (err) {1147 while (reader.readUntilDelimiterOrEof(&line_buf, '\n') catch |err| switch (err) {
1147 error.StreamTooLong => blk: {1148 error.StreamTooLong => blk: {
1148 // Skip to the delimiter in the stream, to fix parsing1149 // Skip to the delimiter in the reader, to fix parsing
1149 try stream.skipUntilDelimiterOrEof('\n');1150 try reader.skipUntilDelimiterOrEof('\n');
1150 // Use the truncated line. A truncated comment or hostname will be handled correctly.1151 // Use the truncated line. A truncated comment or hostname will be handled correctly.
1151 break :blk &line_buf;1152 break :blk &line_buf;
1152 },1153 },
1153 else => |e| return e,1154 else => |e| return e,
1154 }) |line| {1155 }) |line| {
1155 const no_comment_line = mem.split(u8, line, "#").next().?;1156 var split_it = mem.split(u8, line, "#");
1157 const no_comment_line = split_it.next().?;
11561158
1157 var line_it = mem.tokenize(u8, no_comment_line, " \t");1159 var line_it = mem.tokenize(u8, no_comment_line, " \t");
1158 const ip_text = line_it.next() orelse continue;1160 const ip_text = line_it.next() orelse continue;
lib/std/zig/c_translation.zig+29-7
...@@ -8,10 +8,19 @@ pub fn cast(comptime DestType: type, target: anytype) DestType {...@@ -8,10 +8,19 @@ pub fn cast(comptime DestType: type, target: anytype) DestType {
8 // this function should behave like transCCast in translate-c, except it's for macros8 // this function should behave like transCCast in translate-c, except it's for macros
9 const SourceType = @TypeOf(target);9 const SourceType = @TypeOf(target);
10 switch (@typeInfo(DestType)) {10 switch (@typeInfo(DestType)) {
11 .Fn, .Pointer => return castToPtr(DestType, SourceType, target),11 .Fn => if (@import("builtin").zig_backend == .stage1)
12 return castToPtr(DestType, SourceType, target)
13 else
14 return castToPtr(*const DestType, SourceType, target),
15 .Pointer => return castToPtr(DestType, SourceType, target),
12 .Optional => |dest_opt| {16 .Optional => |dest_opt| {
13 if (@typeInfo(dest_opt.child) == .Pointer or @typeInfo(dest_opt.child) == .Fn) {17 if (@typeInfo(dest_opt.child) == .Pointer) {
14 return castToPtr(DestType, SourceType, target);18 return castToPtr(DestType, SourceType, target);
19 } else if (@typeInfo(dest_opt.child) == .Fn) {
20 if (@import("builtin").zig_backend == .stage1)
21 return castToPtr(DestType, SourceType, target)
22 else
23 return castToPtr(?*const dest_opt.child, SourceType, target);
15 }24 }
16 },25 },
17 .Int => {26 .Int => {
...@@ -124,7 +133,10 @@ test "cast" {...@@ -124,7 +133,10 @@ test "cast" {
124 try testing.expect(cast(?*anyopaque, -1) == @intToPtr(?*anyopaque, @bitCast(usize, @as(isize, -1))));133 try testing.expect(cast(?*anyopaque, -1) == @intToPtr(?*anyopaque, @bitCast(usize, @as(isize, -1))));
125 try testing.expect(cast(?*anyopaque, foo) == @intToPtr(?*anyopaque, @bitCast(usize, @as(isize, -1))));134 try testing.expect(cast(?*anyopaque, foo) == @intToPtr(?*anyopaque, @bitCast(usize, @as(isize, -1))));
126135
127 const FnPtr = ?fn (*anyopaque) void;136 const FnPtr = if (@import("builtin").zig_backend == .stage1)
137 ?fn (*anyopaque) void
138 else
139 ?*const fn (*anyopaque) void;
128 try testing.expect(cast(FnPtr, 0) == @intToPtr(FnPtr, @as(usize, 0)));140 try testing.expect(cast(FnPtr, 0) == @intToPtr(FnPtr, @as(usize, 0)));
129 try testing.expect(cast(FnPtr, foo) == @intToPtr(FnPtr, @bitCast(usize, @as(isize, -1))));141 try testing.expect(cast(FnPtr, foo) == @intToPtr(FnPtr, @bitCast(usize, @as(isize, -1))));
130}142}
...@@ -135,9 +147,14 @@ pub fn sizeof(target: anytype) usize {...@@ -135,9 +147,14 @@ pub fn sizeof(target: anytype) usize {
135 switch (@typeInfo(T)) {147 switch (@typeInfo(T)) {
136 .Float, .Int, .Struct, .Union, .Array, .Bool, .Vector => return @sizeOf(T),148 .Float, .Int, .Struct, .Union, .Array, .Bool, .Vector => return @sizeOf(T),
137 .Fn => {149 .Fn => {
138 // sizeof(main) returns 1, sizeof(&main) returns pointer size.150 if (@import("builtin").zig_backend == .stage1) {
139 // We cannot distinguish those types in Zig, so use pointer size.151 // sizeof(main) returns 1, sizeof(&main) returns pointer size.
140 return @sizeOf(T);152 // We cannot distinguish those types in Zig, so use pointer size.
153 return @sizeOf(T);
154 }
155
156 // sizeof(main) in C returns 1
157 return 1;
141 },158 },
142 .Null => return @sizeOf(*anyopaque),159 .Null => return @sizeOf(*anyopaque),
143 .Void => {160 .Void => {
...@@ -233,7 +250,12 @@ test "sizeof" {...@@ -233,7 +250,12 @@ test "sizeof" {
233 try testing.expect(sizeof(*const *const [4:0]u8) == ptr_size);250 try testing.expect(sizeof(*const *const [4:0]u8) == ptr_size);
234 try testing.expect(sizeof(*const [4]u8) == ptr_size);251 try testing.expect(sizeof(*const [4]u8) == ptr_size);
235252
236 try testing.expect(sizeof(sizeof) == @sizeOf(@TypeOf(sizeof)));253 if (@import("builtin").zig_backend == .stage1) {
254 try testing.expect(sizeof(sizeof) == @sizeOf(@TypeOf(sizeof)));
255 } else if (false) { // TODO
256 try testing.expect(sizeof(&sizeof) == @sizeOf(@TypeOf(&sizeof)));
257 try testing.expect(sizeof(sizeof) == 1);
258 }
237259
238 try testing.expect(sizeof(void) == 1);260 try testing.expect(sizeof(void) == 1);
239 try testing.expect(sizeof(anyopaque) == 1);261 try testing.expect(sizeof(anyopaque) == 1);