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![]...@@ -1083,6 +1083,8 @@ pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: var) BufPrintError![]
1083 format(fbs.outStream(), fmt, args) catch |err| switch (err) {1083 format(fbs.outStream(), fmt, args) catch |err| switch (err) {
1084 error.NoSpaceLeft => return error.BufferTooSmall,1084 error.NoSpaceLeft => return error.BufferTooSmall,
1085 };1085 };
1086 //TODO: should we change one of these return signatures?
1087 //return fbs.getWritten();
1086 return buf[0..fbs.pos];1088 return buf[0..fbs.pos];
1087}1089}
10881090
...@@ -1195,18 +1197,15 @@ test "buffer" {...@@ -1195,18 +1197,15 @@ test "buffer" {
1195 var buf1: [32]u8 = undefined;1197 var buf1: [32]u8 = undefined;
1196 var fbs = std.io.fixedBufferStream(&buf1);1198 var fbs = std.io.fixedBufferStream(&buf1);
1197 try formatType(1234, "", FormatOptions{}, fbs.outStream(), default_max_depth);1199 try formatType(1234, "", FormatOptions{}, fbs.outStream(), default_max_depth);
1198 var res = buf1[0..fbs.pos];1200 std.testing.expect(mem.eql(u8, fbs.getWritten(), "1234"));
1199 std.testing.expect(mem.eql(u8, res, "1234"));
12001201
1201 try fbs.seekTo(0);1202 fbs.reset();
1202 try formatType('a', "c", FormatOptions{}, fbs.outStream(), default_max_depth);1203 try formatType('a', "c", FormatOptions{}, fbs.outStream(), default_max_depth);
1203 res = buf1[0..fbs.pos];1204 std.testing.expect(mem.eql(u8, fbs.getWritten(), "a"));
1204 std.testing.expect(mem.eql(u8, res, "a"));
12051205
1206 try fbs.seekTo(0);1206 fbs.reset();
1207 try formatType(0b1100, "b", FormatOptions{}, fbs.outStream(), default_max_depth);1207 try formatType(0b1100, "b", FormatOptions{}, fbs.outStream(), default_max_depth);
1208 res = buf1[0..fbs.pos];1208 std.testing.expect(mem.eql(u8, fbs.getWritten(), "1100"));
1209 std.testing.expect(mem.eql(u8, res, "1100"));
1210 }1209 }
1211}1210}
12121211
...@@ -1583,78 +1582,73 @@ test "formatIntValue with comptime_int" {...@@ -1583,78 +1582,73 @@ test "formatIntValue with comptime_int" {
1583 var buf: [20]u8 = undefined;1582 var buf: [20]u8 = undefined;
1584 var fbs = std.io.fixedBufferStream(&buf);1583 var fbs = std.io.fixedBufferStream(&buf);
1585 try formatIntValue(value, "", FormatOptions{}, fbs.outStream());1584 try formatIntValue(value, "", FormatOptions{}, fbs.outStream());
1586 std.testing.expect(mem.eql(u8, buf[0..fbs.pos], "123456789123456789"));1585 std.testing.expect(mem.eql(u8, fbs.getWritten(), "123456789123456789"));
1587}1586}
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// };
16281587
1629// var inst = S{1588test "formatType max_depth" {
1630// .a = null,1589 const Vec2 = struct {
1631// .tu = TU{ .ptr = null },1590 const SelfType = @This();
1632// .e = E.Two,1591 x: f32,
1633// .vec = Vec2{ .x = 10.2, .y = 2.22 },1592 y: f32,
1634// };1593
1635// inst.a = &inst;1594 pub fn format(
1636// inst.tu.ptr = &inst.tu;1595 self: SelfType,
16371596 comptime fmt: []const u8,
1638// var buf0 = std.ArrayList(u8).init(std.testing.allocator);1597 options: FormatOptions,
1639// defer buf0.deinit();1598 out_stream: var,
1640// try formatType(inst, "", FormatOptions{}, &buf0, @TypeOf(std.ArrayList(u8).appendSlice).ReturnType.ErrorSet, std.ArrayList(u8).appendSlice, 0);1599 ) !void {
1641// std.testing.expect(mem.eql(u8, buf0.toSlice(), "S{ ... }"));1600 if (fmt.len == 0) {
16421601 return std.fmtstream.format(out_stream, "({d:.3},{d:.3})", .{ self.x, self.y });
1643// var buf1 = std.ArrayList(u8).init(std.testing.allocator);1602 } else {
1644// defer buf1.deinit();1603 @compileError("Unknown format string: '" ++ fmt ++ "'");
1645// try formatType(inst, "", FormatOptions{}, &buf1, @TypeOf(std.ArrayList(u8).appendSlice).ReturnType.ErrorSet, std.ArrayList(u8).appendSlice, 1);1604 }
1646// std.testing.expect(mem.eql(u8, buf1.toSlice(), "S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }"));1605 }
16471606 };
1648// var buf2 = std.ArrayList(u8).init(std.testing.allocator);1607 const E = enum {
1649// defer buf2.deinit();1608 One,
1650// try formatType(inst, "", FormatOptions{}, &buf2, @TypeOf(std.ArrayList(u8).appendSlice).ReturnType.ErrorSet, std.ArrayList(u8).appendSlice, 2);1609 Two,
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) }"));1610 Three,
16521611 };
1653// var buf3 = std.ArrayList(u8).init(std.testing.allocator);1612 const TU = union(enum) {
1654// defer buf3.deinit();1613 const SelfType = @This();
1655// try formatType(inst, "", FormatOptions{}, &buf3, @TypeOf(std.ArrayList(u8).appendSlice).ReturnType.ErrorSet, std.ArrayList(u8).appendSlice, 3);1614 float: f32,
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) }"));1615 int: u32,
1657// }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
1659test "positional" {1653test "positional" {
1660 try testFmt("2 1 0", "{2} {1} {0}", .{ @as(usize, 0), @as(usize, 1), @as(usize, 2) });1654 try testFmt("2 1 0", "{2} {1} {0}", .{ @as(usize, 0), @as(usize, 1), @as(usize, 2) });