authorgravatar for vincent@rischmann.frVincent Rischmann <vincent@rischmann.fr> 2020-04-01 12:37:02+02:00
committergravatar for vincent@rischmann.frVincent Rischmann <vincent@rischmann.fr> 2020-04-01 12:37:02+02:00
logf46121b8fc1df6d97bd96116166366ed4dcc5a8c
tree7256eb2b20d5469ae55586e7111062c718f41791
parenteddf491bf4babc0d3a2d6ea065c91d9a744ea090
signaturelock-open Commit is signed but in an unrecognized format.

io: fix serialization compilation and tests

1 files changed, 50 insertions(+), 49 deletions(-)

lib/std/io/serialization.zig+50-49
......@@ -5,6 +5,7 @@ const assert = std.debug.assert;
55const math = std.math;
66const meta = std.meta;
77const trait = meta.trait;
8const testing = std.testing;
89
910pub const Packing = enum {
1011 /// Pack data to byte alignment
......@@ -273,7 +274,7 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime packing: Packing, co
273274 if (comptime trait.hasFn("serialize")(T)) return T.serialize(value, self);
274275
275276 if (comptime trait.isPacked(T) and packing != .Bit) {
276 var packed_serializer = Serializer(endian, .Bit, Error).init(self.out_stream);
277 var packed_serializer = Serializer(endian, .Bit, OutStreamType).init(self.out_stream);
277278 try packed_serializer.serialize(value);
278279 try packed_serializer.flush();
279280 return;
......@@ -364,28 +365,28 @@ fn testIntSerializerDeserializer(comptime endian: builtin.Endian, comptime packi
364365
365366 var data_mem: [total_bytes]u8 = undefined;
366367 var out = io.fixedBufferStream(&data_mem);
367 var serializer = serializer(endian, packing, out.outStream());
368 var _serializer = serializer(endian, packing, out.outStream());
368369
369370 var in = io.fixedBufferStream(&data_mem);
370 var deserializer = Deserializer(endian, packing, in.inStream());
371 var _deserializer = deserializer(endian, packing, in.inStream());
371372
372373 comptime var i = 0;
373374 inline while (i <= max_test_bitsize) : (i += 1) {
374375 const U = std.meta.IntType(false, i);
375376 const S = std.meta.IntType(true, i);
376 try serializer.serializeInt(@as(U, i));
377 if (i != 0) try serializer.serializeInt(@as(S, -1)) else try serializer.serialize(@as(S, 0));
377 try _serializer.serializeInt(@as(U, i));
378 if (i != 0) try _serializer.serializeInt(@as(S, -1)) else try _serializer.serialize(@as(S, 0));
378379 }
379 try serializer.flush();
380 try _serializer.flush();
380381
381382 i = 0;
382383 inline while (i <= max_test_bitsize) : (i += 1) {
383384 const U = std.meta.IntType(false, i);
384385 const S = std.meta.IntType(true, i);
385 const x = try deserializer.deserializeInt(U);
386 const y = try deserializer.deserializeInt(S);
387 expect(x == @as(U, i));
388 if (i != 0) expect(y == @as(S, -1)) else expect(y == 0);
386 const x = try _deserializer.deserializeInt(U);
387 const y = try _deserializer.deserializeInt(S);
388 testing.expect(x == @as(U, i));
389 if (i != 0) testing.expect(y == @as(S, -1)) else testing.expect(y == 0);
389390 }
390391
391392 const u8_bit_count = comptime meta.bitCount(u8);
......@@ -395,7 +396,7 @@ fn testIntSerializerDeserializer(comptime endian: builtin.Endian, comptime packi
395396 const extra_packed_byte = @boolToInt(total_bits % u8_bit_count > 0);
396397 const total_packed_bytes = (total_bits / u8_bit_count) + extra_packed_byte;
397398
398 expect(in.pos == if (packing == .Bit) total_packed_bytes else total_bytes);
399 testing.expect(in.pos == if (packing == .Bit) total_packed_bytes else total_bytes);
399400
400401 //Verify that empty error set works with serializer.
401402 //deserializer is covered by FixedBufferStream
......@@ -421,35 +422,35 @@ fn testIntSerializerDeserializerInfNaN(
421422 var data_mem: [mem_size]u8 = undefined;
422423
423424 var out = io.fixedBufferStream(&data_mem);
424 var serializer = serializer(endian, packing, out.outStream());
425 var _serializer = serializer(endian, packing, out.outStream());
425426
426427 var in = io.fixedBufferStream(&data_mem);
427 var deserializer = deserializer(endian, packing, in.inStream());
428 var _deserializer = deserializer(endian, packing, in.inStream());
428429
429430 //@TODO: isInf/isNan not currently implemented for f128.
430 try serializer.serialize(std.math.nan(f16));
431 try serializer.serialize(std.math.inf(f16));
432 try serializer.serialize(std.math.nan(f32));
433 try serializer.serialize(std.math.inf(f32));
434 try serializer.serialize(std.math.nan(f64));
435 try serializer.serialize(std.math.inf(f64));
431 try _serializer.serialize(std.math.nan(f16));
432 try _serializer.serialize(std.math.inf(f16));
433 try _serializer.serialize(std.math.nan(f32));
434 try _serializer.serialize(std.math.inf(f32));
435 try _serializer.serialize(std.math.nan(f64));
436 try _serializer.serialize(std.math.inf(f64));
436437 //try serializer.serialize(std.math.nan(f128));
437438 //try serializer.serialize(std.math.inf(f128));
438 const nan_check_f16 = try deserializer.deserialize(f16);
439 const inf_check_f16 = try deserializer.deserialize(f16);
440 const nan_check_f32 = try deserializer.deserialize(f32);
441 deserializer.alignToByte();
442 const inf_check_f32 = try deserializer.deserialize(f32);
443 const nan_check_f64 = try deserializer.deserialize(f64);
444 const inf_check_f64 = try deserializer.deserialize(f64);
439 const nan_check_f16 = try _deserializer.deserialize(f16);
440 const inf_check_f16 = try _deserializer.deserialize(f16);
441 const nan_check_f32 = try _deserializer.deserialize(f32);
442 _deserializer.alignToByte();
443 const inf_check_f32 = try _deserializer.deserialize(f32);
444 const nan_check_f64 = try _deserializer.deserialize(f64);
445 const inf_check_f64 = try _deserializer.deserialize(f64);
445446 //const nan_check_f128 = try deserializer.deserialize(f128);
446447 //const inf_check_f128 = try deserializer.deserialize(f128);
447 expect(std.math.isNan(nan_check_f16));
448 expect(std.math.isInf(inf_check_f16));
449 expect(std.math.isNan(nan_check_f32));
450 expect(std.math.isInf(inf_check_f32));
451 expect(std.math.isNan(nan_check_f64));
452 expect(std.math.isInf(inf_check_f64));
448 testing.expect(std.math.isNan(nan_check_f16));
449 testing.expect(std.math.isInf(inf_check_f16));
450 testing.expect(std.math.isNan(nan_check_f32));
451 testing.expect(std.math.isInf(inf_check_f32));
452 testing.expect(std.math.isNan(nan_check_f64));
453 testing.expect(std.math.isInf(inf_check_f64));
453454 //expect(std.math.isNan(nan_check_f128));
454455 //expect(std.math.isInf(inf_check_f128));
455456}
......@@ -461,8 +462,8 @@ test "Serializer/Deserializer Int: Inf/NaN" {
461462 try testIntSerializerDeserializerInfNaN(.Little, .Bit);
462463}
463464
464fn testAlternateSerializer(self: var, serializer: var) !void {
465 try serializer.serialize(self.f_f16);
465fn testAlternateSerializer(self: var, _serializer: var) !void {
466 try _serializer.serialize(self.f_f16);
466467}
467468
468469fn testSerializerDeserializer(comptime endian: builtin.Endian, comptime packing: io.Packing) !void {
......@@ -502,8 +503,8 @@ fn testSerializerDeserializer(comptime endian: builtin.Endian, comptime packing:
502503 f_f16: f16,
503504 f_unused_u32: u32,
504505
505 pub fn deserialize(self: *@This(), deserializer: var) !void {
506 try deserializer.deserializeInto(&self.f_f16);
506 pub fn deserialize(self: *@This(), _deserializer: var) !void {
507 try _deserializer.deserializeInto(&self.f_f16);
507508 self.f_unused_u32 = 47;
508509 }
509510
......@@ -550,15 +551,15 @@ fn testSerializerDeserializer(comptime endian: builtin.Endian, comptime packing:
550551
551552 var data_mem: [@sizeOf(MyStruct)]u8 = undefined;
552553 var out = io.fixedBufferStream(&data_mem);
553 var serializer = serializer(endian, packing, out.outStream());
554 var _serializer = serializer(endian, packing, out.outStream());
554555
555556 var in = io.fixedBufferStream(&data_mem);
556 var deserializer = deserializer(endian, packing, in.inStream());
557 var _deserializer = deserializer(endian, packing, in.inStream());
557558
558 try serializer.serialize(my_inst);
559 try _serializer.serialize(my_inst);
559560
560 const my_copy = try deserializer.deserialize(MyStruct);
561 expect(meta.eql(my_copy, my_inst));
561 const my_copy = try _deserializer.deserialize(MyStruct);
562 testing.expect(meta.eql(my_copy, my_inst));
562563}
563564
564565test "Serializer/Deserializer generic" {
......@@ -584,18 +585,18 @@ fn testBadData(comptime endian: builtin.Endian, comptime packing: io.Packing) !v
584585 };
585586
586587 var data_mem: [4]u8 = undefined;
587 var out = io.fixedBufferStream.init(&data_mem);
588 var serializer = serializer(endian, packing, out.outStream());
588 var out = io.fixedBufferStream(&data_mem);
589 var _serializer = serializer(endian, packing, out.outStream());
589590
590591 var in = io.fixedBufferStream(&data_mem);
591 var deserializer = deserializer(endian, packing, in.inStream());
592 var _deserializer = deserializer(endian, packing, in.inStream());
592593
593 try serializer.serialize(@as(u14, 3));
594 expectError(error.InvalidEnumTag, deserializer.deserialize(A));
594 try _serializer.serialize(@as(u14, 3));
595 testing.expectError(error.InvalidEnumTag, _deserializer.deserialize(A));
595596 out.pos = 0;
596 try serializer.serialize(@as(u14, 3));
597 try serializer.serialize(@as(u14, 88));
598 expectError(error.InvalidEnumTag, deserializer.deserialize(C));
597 try _serializer.serialize(@as(u14, 3));
598 try _serializer.serialize(@as(u14, 88));
599 testing.expectError(error.InvalidEnumTag, _deserializer.deserialize(C));
599600}
600601
601602test "Deserializer bad data" {