| ... | ... | @@ -103,25 +103,32 @@ pub fn Queue(comptime T: type) type { |
| 103 | 103 | } |
| 104 | 104 | |
| 105 | 105 | pub fn dump(self: *Self) void { |
| 106 | | const held = self.mutex.acquire(); |
| 107 | | defer held.release(); |
| 106 | var stderr_file = std.io.getStdErr() catch return; |
| 107 | const stderr = &stderr_file.outStream().stream; |
| 108 | const Error = @typeInfo(@typeOf(stderr)).Pointer.child.Error; |
| 108 | 109 | |
| 109 | | std.debug.warn("head: "); |
| 110 | | dumpRecursive(self.head, 0); |
| 111 | | std.debug.warn("tail: "); |
| 112 | | dumpRecursive(self.tail, 0); |
| 110 | self.dumpToStream(Error, stderr) catch return; |
| 113 | 111 | } |
| 114 | 112 | |
| 115 | | fn dumpRecursive(optional_node: ?*Node, indent: usize) void { |
| 116 | | var stderr_file = std.io.getStdErr() catch return; |
| 117 | | const stderr = &stderr_file.outStream().stream; |
| 118 | | stderr.writeByteNTimes(' ', indent) catch return; |
| 119 | | if (optional_node) |node| { |
| 120 | | std.debug.warn("0x{x}={}\n", @ptrToInt(node), node.data); |
| 121 | | dumpRecursive(node.next, indent + 1); |
| 122 | | } else { |
| 123 | | std.debug.warn("(null)\n"); |
| 124 | | } |
| 113 | pub fn dumpToStream(self: *Self, comptime Error: type, stream: *std.io.OutStream(Error)) Error!void { |
| 114 | const S = struct.{ |
| 115 | fn dumpRecursive(s: *std.io.OutStream(Error), optional_node: ?*Node, indent: usize) Error!void { |
| 116 | try s.writeByteNTimes(' ', indent); |
| 117 | if (optional_node) |node| { |
| 118 | try s.print("0x{x}={}\n", @ptrToInt(node), node.data); |
| 119 | try dumpRecursive(s, node.next, indent + 1); |
| 120 | } else { |
| 121 | try s.print("(null)\n"); |
| 122 | } |
| 123 | } |
| 124 | }; |
| 125 | const held = self.mutex.acquire(); |
| 126 | defer held.release(); |
| 127 | |
| 128 | try stream.print("head: "); |
| 129 | try S.dumpRecursive(stream, self.head, 0); |
| 130 | try stream.print("tail: "); |
| 131 | try S.dumpRecursive(stream, self.tail, 0); |
| 125 | 132 | } |
| 126 | 133 | }; |
| 127 | 134 | } |
| ... | ... | @@ -274,3 +281,63 @@ test "std.atomic.Queue single-threaded" { |
| 274 | 281 | |
| 275 | 282 | assert(queue.get() == null); |
| 276 | 283 | } |
| 284 | |
| 285 | test "std.atomic.Queue dump" { |
| 286 | const mem = std.mem; |
| 287 | const SliceOutStream = std.io.SliceOutStream; |
| 288 | var buffer: [1024]u8 = undefined; |
| 289 | var expected_buffer: [1024]u8 = undefined; |
| 290 | var sos = SliceOutStream.init(buffer[0..]); |
| 291 | |
| 292 | var queue = Queue(i32).init(); |
| 293 | |
| 294 | // Test empty stream |
| 295 | sos.reset(); |
| 296 | try queue.dumpToStream(SliceOutStream.Error, &sos.stream); |
| 297 | assert(mem.eql(u8, buffer[0..sos.pos], |
| 298 | \\head: (null) |
| 299 | \\tail: (null) |
| 300 | \\ |
| 301 | )); |
| 302 | |
| 303 | // Test a stream with one element |
| 304 | var node_0 = Queue(i32).Node.{ |
| 305 | .data = 1, |
| 306 | .next = undefined, |
| 307 | .prev = undefined, |
| 308 | }; |
| 309 | queue.put(&node_0); |
| 310 | |
| 311 | sos.reset(); |
| 312 | try queue.dumpToStream(SliceOutStream.Error, &sos.stream); |
| 313 | |
| 314 | var expected = try std.fmt.bufPrint(expected_buffer[0..], |
| 315 | \\head: 0x{x}=1 |
| 316 | \\ (null) |
| 317 | \\tail: 0x{x}=1 |
| 318 | \\ (null) |
| 319 | \\ |
| 320 | , @ptrToInt(queue.head), @ptrToInt(queue.tail)); |
| 321 | assert(mem.eql(u8, buffer[0..sos.pos], expected)); |
| 322 | |
| 323 | // Test a stream with two elements |
| 324 | var node_1 = Queue(i32).Node.{ |
| 325 | .data = 2, |
| 326 | .next = undefined, |
| 327 | .prev = undefined, |
| 328 | }; |
| 329 | queue.put(&node_1); |
| 330 | |
| 331 | sos.reset(); |
| 332 | try queue.dumpToStream(SliceOutStream.Error, &sos.stream); |
| 333 | |
| 334 | expected = try std.fmt.bufPrint(expected_buffer[0..], |
| 335 | \\head: 0x{x}=1 |
| 336 | \\ 0x{x}=2 |
| 337 | \\ (null) |
| 338 | \\tail: 0x{x}=2 |
| 339 | \\ (null) |
| 340 | \\ |
| 341 | , @ptrToInt(queue.head), @ptrToInt(queue.head.?.next), @ptrToInt(queue.tail)); |
| 342 | assert(mem.eql(u8, buffer[0..sos.pos], expected)); |
| 343 | } |
Andrew Kelley <andrew@ziglang.org> 2018-10-31 10:44:25-04:00
Commit is signed but in an unrecognized format.