authorgravatar for igor.anic@gmail.comIgor Anić <igor.anic@gmail.com> 2024-02-14 21:06:45+01:00
committergravatar for igor.anic@gmail.comIgor Anić <igor.anic@gmail.com> 2024-02-14 21:06:45+01:00
log0afe808928f3d4fd122c746d6eae1e88ff7aace1
treef8485d1b0efc544aac0066d5274493bcd434cc71
parentd49cdf5b2d2e30ab9188c54e359f19768d890bf3

remove testing struct sizes

It was usefull during development. From andrewrk code review comment: In fact, Zig does not guarantee the @sizeOf structs, and so these tests are not valid.

2 files changed, 0 insertions(+), 63 deletions(-)

lib/std/compress/flate/deflate.zig-44
...@@ -602,50 +602,6 @@ const TestTokenWriter = struct {...@@ -602,50 +602,6 @@ const TestTokenWriter = struct {
602 pub fn flush(_: *Self) !void {}602 pub fn flush(_: *Self) !void {}
603};603};
604604
605test "flate.Deflate struct sizes" {
606 if (@sizeOf(usize) != 8) return error.SkipZigTest;
607
608 try expect(@sizeOf(Token) == 4);
609
610 // list: (1 << 15) * 4 = 128k + pos: 8
611 const tokens_size = 128 * 1024 + 8;
612 try expect(@sizeOf(Tokens) == tokens_size);
613
614 // head: (1 << 15) * 2 = 64k, chain: (32768 * 2) * 2 = 128k = 192k
615 const lookup_size = 192 * 1024;
616 try expect(@sizeOf(Lookup) == lookup_size);
617
618 // buffer: (32k * 2), wp: 8, rp: 8, fp: 8
619 const window_size = 64 * 1024 + 8 + 8 + 8;
620 try expect(@sizeOf(SlidingWindow) == window_size);
621
622 const Bw = BlockWriter(@TypeOf(io.null_writer));
623 // huffman bit writer internal: 11480
624 const hbw_size = 11472; // 11.2k
625 try expect(@sizeOf(Bw) == hbw_size);
626
627 const D = Deflate(.raw, @TypeOf(io.null_writer), Bw);
628 // 404744, 395.26K
629 // ?Token: 6, ?u8: 2, level: 8
630 try expect(@sizeOf(D) == tokens_size + lookup_size + window_size + hbw_size + 24);
631 //print("Delfate size: {d} {d}\n", .{ @sizeOf(D), tokens_size + lookup_size + hbw_size + window_size });
632
633 // current std lib deflate allocation:
634 // 797_901, 779.2k
635 // measured with:
636 // var la = std.heap.logToWriterAllocator(testing.allocator, io.getStdOut().writer());
637 // const allocator = la.allocator();
638 // var cmp = try std.compress.deflate.compressor(allocator, io.null_writer, .{});
639 // defer cmp.deinit();
640
641 const HC = huffman.Compressor(.raw, @TypeOf(io.null_writer));
642 //print("size of HOC {d}\n", .{@sizeOf(HOC)});
643 try expect(@sizeOf(HC) == 77024);
644 // 64K buffer
645 // 11480 huffman_encoded
646 // 8 buffer write pointer
647}
648
649test "flate deflate file tokenization" {605test "flate deflate file tokenization" {
650 const levels = [_]Level{ .level_4, .level_5, .level_6, .level_7, .level_8, .level_9 };606 const levels = [_]Level{ .level_4, .level_5, .level_6, .level_7, .level_8, .level_9 };
651 const cases = [_]struct {607 const cases = [_]struct {
lib/std/compress/flate/inflate.zig-19
...@@ -341,25 +341,6 @@ pub fn Inflate(comptime container: Container, comptime ReaderType: type) type {...@@ -341,25 +341,6 @@ pub fn Inflate(comptime container: Container, comptime ReaderType: type) type {
341 };341 };
342}342}
343343
344test "flate.Inflate struct sizes" {
345 if (@sizeOf(usize) != 8) return error.SkipZigTest;
346
347 var fbs = std.io.fixedBufferStream("");
348 const ReaderType = @TypeOf(fbs.reader());
349 const inflate_size = @sizeOf(Inflate(.gzip, ReaderType));
350
351 try testing.expectEqual(76320, inflate_size);
352 try testing.expectEqual(
353 @sizeOf(CircularBuffer) + @sizeOf(hfd.LiteralDecoder) + @sizeOf(hfd.DistanceDecoder) + 48,
354 inflate_size,
355 );
356 try testing.expectEqual(65536 + 8 + 8, @sizeOf(CircularBuffer));
357 try testing.expectEqual(8, @sizeOf(Container.raw.Hasher()));
358 try testing.expectEqual(24, @sizeOf(BitReader(ReaderType)));
359 try testing.expectEqual(6384, @sizeOf(hfd.LiteralDecoder));
360 try testing.expectEqual(4336, @sizeOf(hfd.DistanceDecoder));
361}
362
363test "flate.Inflate decompress" {344test "flate.Inflate decompress" {
364 const cases = [_]struct {345 const cases = [_]struct {
365 in: []const u8,346 in: []const u8,