commit 0628c2e2bae0a847dee4863521d9e6f4d9383e83 (tree)
parent a5af78c376fc41424b81ea83766b38a0a1d17870
Author: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 1 Apr 2020 10:21:27 -0400
Merge pull request #4895 from vrischmann/fix-io-tests
Fix io tests
Diffstat:
4 files changed, 70 insertions(+), 55 deletions(-)
diff --git a/lib/std/io.zig b/lib/std/io.zig
@@ -141,6 +141,20 @@ test "null_out_stream" {
}
test "" {
+ _ = @import("io/bit_in_stream.zig");
+ _ = @import("io/bit_out_stream.zig");
+ _ = @import("io/buffered_atomic_file.zig");
+ _ = @import("io/buffered_in_stream.zig");
+ _ = @import("io/buffered_out_stream.zig");
+ _ = @import("io/c_out_stream.zig");
+ _ = @import("io/counting_out_stream.zig");
+ _ = @import("io/fixed_buffer_stream.zig");
+ _ = @import("io/in_stream.zig");
+ _ = @import("io/out_stream.zig");
+ _ = @import("io/peek_stream.zig");
+ _ = @import("io/seekable_stream.zig");
+ _ = @import("io/serialization.zig");
+ _ = @import("io/stream_source.zig");
_ = @import("io/test.zig");
}
diff --git a/lib/std/io/c_out_stream.zig b/lib/std/io/c_out_stream.zig
@@ -36,9 +36,9 @@ test "" {
const out_file = std.c.fopen(filename, "w") orelse return error.UnableToOpenTestFile;
defer {
_ = std.c.fclose(out_file);
- fs.cwd().deleteFileZ(filename) catch {};
+ std.fs.cwd().deleteFileZ(filename) catch {};
}
- const out_stream = &io.COutStream.init(out_file).stream;
+ const out_stream = cOutStream(out_file);
try out_stream.print("hi: {}\n", .{@as(i32, 123)});
}
diff --git a/lib/std/io/peek_stream.zig b/lib/std/io/peek_stream.zig
@@ -24,7 +24,7 @@ pub fn PeekStream(
.Static => struct {
pub fn init(base: InStreamType) Self {
return .{
- .base = base,
+ .unbuffered_in_stream = base,
.fifo = FifoType.init(),
};
}
@@ -32,7 +32,7 @@ pub fn PeekStream(
.Slice => struct {
pub fn init(base: InStreamType, buf: []u8) Self {
return .{
- .base = base,
+ .unbuffered_in_stream = base,
.fifo = FifoType.init(buf),
};
}
@@ -40,7 +40,7 @@ pub fn PeekStream(
.Dynamic => struct {
pub fn init(base: InStreamType, allocator: *mem.Allocator) Self {
return .{
- .base = base,
+ .unbuffered_in_stream = base,
.fifo = FifoType.init(allocator),
};
}
@@ -61,7 +61,7 @@ pub fn PeekStream(
if (dest_index == dest.len) return dest_index;
// ask the backing stream for more
- dest_index += try self.base.read(dest[dest_index..]);
+ dest_index += try self.unbuffered_in_stream.read(dest[dest_index..]);
return dest_index;
}
diff --git a/lib/std/io/serialization.zig b/lib/std/io/serialization.zig
@@ -5,6 +5,7 @@ const assert = std.debug.assert;
const math = std.math;
const meta = std.meta;
const trait = meta.trait;
+const testing = std.testing;
pub const Packing = enum {
/// Pack data to byte alignment
@@ -273,7 +274,7 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime packing: Packing, co
if (comptime trait.hasFn("serialize")(T)) return T.serialize(value, self);
if (comptime trait.isPacked(T) and packing != .Bit) {
- var packed_serializer = Serializer(endian, .Bit, Error).init(self.out_stream);
+ var packed_serializer = Serializer(endian, .Bit, OutStreamType).init(self.out_stream);
try packed_serializer.serialize(value);
try packed_serializer.flush();
return;
@@ -364,28 +365,28 @@ fn testIntSerializerDeserializer(comptime endian: builtin.Endian, comptime packi
var data_mem: [total_bytes]u8 = undefined;
var out = io.fixedBufferStream(&data_mem);
- var serializer = serializer(endian, packing, out.outStream());
+ var _serializer = serializer(endian, packing, out.outStream());
var in = io.fixedBufferStream(&data_mem);
- var deserializer = Deserializer(endian, packing, in.inStream());
+ var _deserializer = deserializer(endian, packing, in.inStream());
comptime var i = 0;
inline while (i <= max_test_bitsize) : (i += 1) {
const U = std.meta.IntType(false, i);
const S = std.meta.IntType(true, i);
- try serializer.serializeInt(@as(U, i));
- if (i != 0) try serializer.serializeInt(@as(S, -1)) else try serializer.serialize(@as(S, 0));
+ try _serializer.serializeInt(@as(U, i));
+ if (i != 0) try _serializer.serializeInt(@as(S, -1)) else try _serializer.serialize(@as(S, 0));
}
- try serializer.flush();
+ try _serializer.flush();
i = 0;
inline while (i <= max_test_bitsize) : (i += 1) {
const U = std.meta.IntType(false, i);
const S = std.meta.IntType(true, i);
- const x = try deserializer.deserializeInt(U);
- const y = try deserializer.deserializeInt(S);
- expect(x == @as(U, i));
- if (i != 0) expect(y == @as(S, -1)) else expect(y == 0);
+ const x = try _deserializer.deserializeInt(U);
+ const y = try _deserializer.deserializeInt(S);
+ testing.expect(x == @as(U, i));
+ if (i != 0) testing.expect(y == @as(S, -1)) else testing.expect(y == 0);
}
const u8_bit_count = comptime meta.bitCount(u8);
@@ -395,7 +396,7 @@ fn testIntSerializerDeserializer(comptime endian: builtin.Endian, comptime packi
const extra_packed_byte = @boolToInt(total_bits % u8_bit_count > 0);
const total_packed_bytes = (total_bits / u8_bit_count) + extra_packed_byte;
- expect(in.pos == if (packing == .Bit) total_packed_bytes else total_bytes);
+ testing.expect(in.pos == if (packing == .Bit) total_packed_bytes else total_bytes);
//Verify that empty error set works with serializer.
//deserializer is covered by FixedBufferStream
@@ -421,35 +422,35 @@ fn testIntSerializerDeserializerInfNaN(
var data_mem: [mem_size]u8 = undefined;
var out = io.fixedBufferStream(&data_mem);
- var serializer = serializer(endian, packing, out.outStream());
+ var _serializer = serializer(endian, packing, out.outStream());
var in = io.fixedBufferStream(&data_mem);
- var deserializer = deserializer(endian, packing, in.inStream());
+ var _deserializer = deserializer(endian, packing, in.inStream());
//@TODO: isInf/isNan not currently implemented for f128.
- try serializer.serialize(std.math.nan(f16));
- try serializer.serialize(std.math.inf(f16));
- try serializer.serialize(std.math.nan(f32));
- try serializer.serialize(std.math.inf(f32));
- try serializer.serialize(std.math.nan(f64));
- try serializer.serialize(std.math.inf(f64));
+ try _serializer.serialize(std.math.nan(f16));
+ try _serializer.serialize(std.math.inf(f16));
+ try _serializer.serialize(std.math.nan(f32));
+ try _serializer.serialize(std.math.inf(f32));
+ try _serializer.serialize(std.math.nan(f64));
+ try _serializer.serialize(std.math.inf(f64));
//try serializer.serialize(std.math.nan(f128));
//try serializer.serialize(std.math.inf(f128));
- const nan_check_f16 = try deserializer.deserialize(f16);
- const inf_check_f16 = try deserializer.deserialize(f16);
- const nan_check_f32 = try deserializer.deserialize(f32);
- deserializer.alignToByte();
- const inf_check_f32 = try deserializer.deserialize(f32);
- const nan_check_f64 = try deserializer.deserialize(f64);
- const inf_check_f64 = try deserializer.deserialize(f64);
+ const nan_check_f16 = try _deserializer.deserialize(f16);
+ const inf_check_f16 = try _deserializer.deserialize(f16);
+ const nan_check_f32 = try _deserializer.deserialize(f32);
+ _deserializer.alignToByte();
+ const inf_check_f32 = try _deserializer.deserialize(f32);
+ const nan_check_f64 = try _deserializer.deserialize(f64);
+ const inf_check_f64 = try _deserializer.deserialize(f64);
//const nan_check_f128 = try deserializer.deserialize(f128);
//const inf_check_f128 = try deserializer.deserialize(f128);
- expect(std.math.isNan(nan_check_f16));
- expect(std.math.isInf(inf_check_f16));
- expect(std.math.isNan(nan_check_f32));
- expect(std.math.isInf(inf_check_f32));
- expect(std.math.isNan(nan_check_f64));
- expect(std.math.isInf(inf_check_f64));
+ testing.expect(std.math.isNan(nan_check_f16));
+ testing.expect(std.math.isInf(inf_check_f16));
+ testing.expect(std.math.isNan(nan_check_f32));
+ testing.expect(std.math.isInf(inf_check_f32));
+ testing.expect(std.math.isNan(nan_check_f64));
+ testing.expect(std.math.isInf(inf_check_f64));
//expect(std.math.isNan(nan_check_f128));
//expect(std.math.isInf(inf_check_f128));
}
@@ -461,8 +462,8 @@ test "Serializer/Deserializer Int: Inf/NaN" {
try testIntSerializerDeserializerInfNaN(.Little, .Bit);
}
-fn testAlternateSerializer(self: var, serializer: var) !void {
- try serializer.serialize(self.f_f16);
+fn testAlternateSerializer(self: var, _serializer: var) !void {
+ try _serializer.serialize(self.f_f16);
}
fn testSerializerDeserializer(comptime endian: builtin.Endian, comptime packing: io.Packing) !void {
@@ -502,8 +503,8 @@ fn testSerializerDeserializer(comptime endian: builtin.Endian, comptime packing:
f_f16: f16,
f_unused_u32: u32,
- pub fn deserialize(self: *@This(), deserializer: var) !void {
- try deserializer.deserializeInto(&self.f_f16);
+ pub fn deserialize(self: *@This(), _deserializer: var) !void {
+ try _deserializer.deserializeInto(&self.f_f16);
self.f_unused_u32 = 47;
}
@@ -550,15 +551,15 @@ fn testSerializerDeserializer(comptime endian: builtin.Endian, comptime packing:
var data_mem: [@sizeOf(MyStruct)]u8 = undefined;
var out = io.fixedBufferStream(&data_mem);
- var serializer = serializer(endian, packing, out.outStream());
+ var _serializer = serializer(endian, packing, out.outStream());
var in = io.fixedBufferStream(&data_mem);
- var deserializer = deserializer(endian, packing, in.inStream());
+ var _deserializer = deserializer(endian, packing, in.inStream());
- try serializer.serialize(my_inst);
+ try _serializer.serialize(my_inst);
- const my_copy = try deserializer.deserialize(MyStruct);
- expect(meta.eql(my_copy, my_inst));
+ const my_copy = try _deserializer.deserialize(MyStruct);
+ testing.expect(meta.eql(my_copy, my_inst));
}
test "Serializer/Deserializer generic" {
@@ -584,18 +585,18 @@ fn testBadData(comptime endian: builtin.Endian, comptime packing: io.Packing) !v
};
var data_mem: [4]u8 = undefined;
- var out = io.fixedBufferStream.init(&data_mem);
- var serializer = serializer(endian, packing, out.outStream());
+ var out = io.fixedBufferStream(&data_mem);
+ var _serializer = serializer(endian, packing, out.outStream());
var in = io.fixedBufferStream(&data_mem);
- var deserializer = deserializer(endian, packing, in.inStream());
+ var _deserializer = deserializer(endian, packing, in.inStream());
- try serializer.serialize(@as(u14, 3));
- expectError(error.InvalidEnumTag, deserializer.deserialize(A));
+ try _serializer.serialize(@as(u14, 3));
+ testing.expectError(error.InvalidEnumTag, _deserializer.deserialize(A));
out.pos = 0;
- try serializer.serialize(@as(u14, 3));
- try serializer.serialize(@as(u14, 88));
- expectError(error.InvalidEnumTag, deserializer.deserialize(C));
+ try _serializer.serialize(@as(u14, 3));
+ try _serializer.serialize(@as(u14, 88));
+ testing.expectError(error.InvalidEnumTag, _deserializer.deserialize(C));
}
test "Deserializer bad data" {
