authorgravatar for benjamin.feng@glassdoor.comBenjamin Feng <benjamin.feng@glassdoor.com> 2020-02-29 15:10:27-06:00
committergravatar for benjamin.feng@glassdoor.comBenjamin Feng <benjamin.feng@glassdoor.com> 2020-03-12 09:25:13-05:00
log1c18ab01a44bf3cbef356ff215e97dfe2788265b
tree4e6540d1eb459fa6c381e051e1ef729f8e825988
parentf51c8f26c195819bb49a641c82ee65bb2f8e3044

Add back max_depth test

1 files changed, 73 insertions(+), 79 deletions(-)

lib/std/fmtstream.zig+73-79
......@@ -1083,6 +1083,8 @@ pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: var) BufPrintError![]
10831083 format(fbs.outStream(), fmt, args) catch |err| switch (err) {
10841084 error.NoSpaceLeft => return error.BufferTooSmall,
10851085 };
1086 //TODO: should we change one of these return signatures?
1087 //return fbs.getWritten();
10861088 return buf[0..fbs.pos];
10871089}
10881090
......@@ -1195,18 +1197,15 @@ test "buffer" {
11951197 var buf1: [32]u8 = undefined;
11961198 var fbs = std.io.fixedBufferStream(&buf1);
11971199 try formatType(1234, "", FormatOptions{}, fbs.outStream(), default_max_depth);
1198 var res = buf1[0..fbs.pos];
1199 std.testing.expect(mem.eql(u8, res, "1234"));
1200 std.testing.expect(mem.eql(u8, fbs.getWritten(), "1234"));
12001201
1201 try fbs.seekTo(0);
1202 fbs.reset();
12021203 try formatType('a', "c", FormatOptions{}, fbs.outStream(), default_max_depth);
1203 res = buf1[0..fbs.pos];
1204 std.testing.expect(mem.eql(u8, res, "a"));
1204 std.testing.expect(mem.eql(u8, fbs.getWritten(), "a"));
12051205
1206 try fbs.seekTo(0);
1206 fbs.reset();
12071207 try formatType(0b1100, "b", FormatOptions{}, fbs.outStream(), default_max_depth);
1208 res = buf1[0..fbs.pos];
1209 std.testing.expect(mem.eql(u8, res, "1100"));
1208 std.testing.expect(mem.eql(u8, fbs.getWritten(), "1100"));
12101209 }
12111210}
12121211
......@@ -1583,78 +1582,73 @@ test "formatIntValue with comptime_int" {
15831582 var buf: [20]u8 = undefined;
15841583 var fbs = std.io.fixedBufferStream(&buf);
15851584 try formatIntValue(value, "", FormatOptions{}, fbs.outStream());
1586 std.testing.expect(mem.eql(u8, buf[0..fbs.pos], "123456789123456789"));
1587}
1588
1589// test "formatType max_depth" {
1590// const Vec2 = struct {
1591// const SelfType = @This();
1592// x: f32,
1593// y: f32,
1594
1595// pub fn format(
1596// self: SelfType,
1597// comptime fmt: []const u8,
1598// options: FormatOptions,
1599// context: var,
1600// comptime Errors: type,
1601// comptime output: fn (@TypeOf(context), []const u8) !void,
1602// ) !void {
1603// if (fmt.len == 0) {
1604// return std.fmtstream.format(out_stream, "({d:.3},{d:.3})", .{ self.x, self.y });
1605// } else {
1606// @compileError("Unknown format string: '" ++ fmt ++ "'");
1607// }
1608// }
1609// };
1610// const E = enum {
1611// One,
1612// Two,
1613// Three,
1614// };
1615// const TU = union(enum) {
1616// const SelfType = @This();
1617// float: f32,
1618// int: u32,
1619// ptr: ?*SelfType,
1620// };
1621// const S = struct {
1622// const SelfType = @This();
1623// a: ?*SelfType,
1624// tu: TU,
1625// e: E,
1626// vec: Vec2,
1627// };
1585 std.testing.expect(mem.eql(u8, fbs.getWritten(), "123456789123456789"));
1586}
16281587
1629// var inst = S{
1630// .a = null,
1631// .tu = TU{ .ptr = null },
1632// .e = E.Two,
1633// .vec = Vec2{ .x = 10.2, .y = 2.22 },
1634// };
1635// inst.a = &inst;
1636// inst.tu.ptr = &inst.tu;
1637
1638// var buf0 = std.ArrayList(u8).init(std.testing.allocator);
1639// defer buf0.deinit();
1640// try formatType(inst, "", FormatOptions{}, &buf0, @TypeOf(std.ArrayList(u8).appendSlice).ReturnType.ErrorSet, std.ArrayList(u8).appendSlice, 0);
1641// std.testing.expect(mem.eql(u8, buf0.toSlice(), "S{ ... }"));
1642
1643// var buf1 = std.ArrayList(u8).init(std.testing.allocator);
1644// defer buf1.deinit();
1645// try formatType(inst, "", FormatOptions{}, &buf1, @TypeOf(std.ArrayList(u8).appendSlice).ReturnType.ErrorSet, std.ArrayList(u8).appendSlice, 1);
1646// std.testing.expect(mem.eql(u8, buf1.toSlice(), "S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }"));
1647
1648// var buf2 = std.ArrayList(u8).init(std.testing.allocator);
1649// defer buf2.deinit();
1650// try formatType(inst, "", FormatOptions{}, &buf2, @TypeOf(std.ArrayList(u8).appendSlice).ReturnType.ErrorSet, std.ArrayList(u8).appendSlice, 2);
1651// 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) }"));
1652
1653// var buf3 = std.ArrayList(u8).init(std.testing.allocator);
1654// defer buf3.deinit();
1655// try formatType(inst, "", FormatOptions{}, &buf3, @TypeOf(std.ArrayList(u8).appendSlice).ReturnType.ErrorSet, std.ArrayList(u8).appendSlice, 3);
1656// 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) }"));
1657// }
1588test "formatType max_depth" {
1589 const Vec2 = struct {
1590 const SelfType = @This();
1591 x: f32,
1592 y: f32,
1593
1594 pub fn format(
1595 self: SelfType,
1596 comptime fmt: []const u8,
1597 options: FormatOptions,
1598 out_stream: var,
1599 ) !void {
1600 if (fmt.len == 0) {
1601 return std.fmtstream.format(out_stream, "({d:.3},{d:.3})", .{ self.x, self.y });
1602 } else {
1603 @compileError("Unknown format string: '" ++ fmt ++ "'");
1604 }
1605 }
1606 };
1607 const E = enum {
1608 One,
1609 Two,
1610 Three,
1611 };
1612 const TU = union(enum) {
1613 const SelfType = @This();
1614 float: f32,
1615 int: u32,
1616 ptr: ?*SelfType,
1617 };
1618 const S = struct {
1619 const SelfType = @This();
1620 a: ?*SelfType,
1621 tu: TU,
1622 e: E,
1623 vec: Vec2,
1624 };
1625
1626 var inst = S{
1627 .a = null,
1628 .tu = TU{ .ptr = null },
1629 .e = E.Two,
1630 .vec = Vec2{ .x = 10.2, .y = 2.22 },
1631 };
1632 inst.a = &inst;
1633 inst.tu.ptr = &inst.tu;
1634
1635 var buf: [1000]u8 = undefined;
1636 var fbs = std.io.fixedBufferStream(&buf);
1637 try formatType(inst, "", FormatOptions{}, fbs.outStream(), 0);
1638 std.testing.expect(mem.eql(u8, fbs.getWritten(), "S{ ... }"));
1639
1640 fbs.reset();
1641 try formatType(inst, "", FormatOptions{}, fbs.outStream(), 1);
1642 std.testing.expect(mem.eql(u8, fbs.getWritten(), "S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }"));
1643
1644 fbs.reset();
1645 try formatType(inst, "", FormatOptions{}, fbs.outStream(), 2);
1646 std.testing.expect(mem.eql(u8, fbs.getWritten(), "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) }"));
1647
1648 fbs.reset();
1649 try formatType(inst, "", FormatOptions{}, fbs.outStream(), 3);
1650 std.testing.expect(mem.eql(u8, fbs.getWritten(), "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) }"));
1651}
16581652
16591653test "positional" {
16601654 try testFmt("2 1 0", "{2} {1} {0}", .{ @as(usize, 0), @as(usize, 1), @as(usize, 2) });