From e40a2ae2fda02d1f958085b5344cd9c354022586 Mon Sep 17 00:00:00 2001 From: vdonadze Date: Fri, 31 Jul 2020 11:34:50 +0400 Subject: [PATCH 01/20] decoder updates --- .../epfast/decoder/IDecodeContext.java | 6 ++-- .../decoder/ascii/DecodeAsciiString.java | 20 +++++++++++-- .../ascii/DecodeMandatoryAsciiString.java | 30 +++++++++++++++++-- .../ascii/DecodeNullableAsciiString.java | 26 ++++++++++++++++ .../decoder/message/PrimitiveInstruction.java | 16 +++------- .../ascii/ReadMandatoryAsciiString.java | 2 +- .../ascii/ReadNullableAsciiString.java | 2 +- .../commands/integer/ReadMandatoryInt32.java | 3 +- .../commands/integer/ReadMandatoryUInt32.java | 3 +- .../commands/integer/ReadNullableInt32.java | 7 ++++- .../commands/integer/ReadNullableUInt32.java | 7 ++++- .../AllOtherOperatorsMissingValue.java | 3 +- .../operators/DefaultMissingValue.java | 3 +- .../decoder/ascii/TestDecodeAsciiString.java | 1 + 14 files changed, 101 insertions(+), 28 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java index 22c7a5d9..90e79273 100644 --- a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java +++ b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java @@ -16,15 +16,17 @@ package com.exactpro.epfast.decoder; +import com.exactpro.epfast.decoder.message.DecoderState; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; public interface IDecodeContext { int CLEAR_STOP_BIT_MASK = 0b01111111; - void decode(ByteBuf buf); + int decode(ByteBuf buf, UnionRegister unionRegister); - void continueDecode(ByteBuf buf); + int continueDecode(ByteBuf buf, UnionRegister unionRegister); boolean isReady(); diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java index 01bafaaf..92fb3c00 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java @@ -18,6 +18,8 @@ import com.exactpro.epfast.decoder.IDecodeContext; import com.exactpro.epfast.decoder.OverflowException; +import com.exactpro.epfast.decoder.message.DecoderState; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; public abstract class DecodeAsciiString implements IDecodeContext { @@ -38,7 +40,7 @@ public abstract class DecodeAsciiString implements IDecodeContext { this.checkOverlong = checkOverlong; } - public void decode(ByteBuf buf) { + public int decode(ByteBuf buf, UnionRegister unionRegister) { reset(); int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); @@ -50,17 +52,31 @@ public void decode(ByteBuf buf) { accumulateValue(buf.getByte(readerIndex++)); } buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(unionRegister); + return 1; + } else { + return 0; + } } - public void continueDecode(ByteBuf buf) { + public int continueDecode(ByteBuf buf, UnionRegister unionRegister) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); while ((readerIndex < readLimit) && !ready) { accumulateValue(buf.getByte(readerIndex++)); } buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(unionRegister); + return 1; + } else { + return 0; + } } + public abstract void setRegisterValue(UnionRegister unionRegister); + public abstract String getValue() throws OverflowException; public boolean isReady() { diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java index bcda7d57..6f9e0a55 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java @@ -17,17 +17,43 @@ package com.exactpro.epfast.decoder.ascii; import com.exactpro.epfast.decoder.OverflowException; +import com.exactpro.epfast.decoder.message.DecoderState; +import com.exactpro.epfast.decoder.message.UnionRegister; public final class DecodeMandatoryAsciiString extends DecodeAsciiString { - public DecodeMandatoryAsciiString() { + public DecodeMandatoryAsciiString() { this(false); } - public DecodeMandatoryAsciiString(boolean checkOverlong) { + public DecodeMandatoryAsciiString(boolean checkOverlong) { super(checkOverlong); } + @Override + public void setRegisterValue(UnionRegister register) { + if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { + register.isOverflow = true; + //TODO what to do with overflow information ? + //throw new OverflowException("String is longer than allowed"); + } + if (zeroCount < stringBuilder.length()) { + if (zeroPreamble && checkOverlong) { + //TODO set register flag + register.isOverflow = true; + //throw new OverflowException("String with zero preamble can't contain any value except 0"); + } else { + register.stringValue = stringBuilder.toString(); + } + } else if (zeroCount == 1) { + register.stringValue = ""; + } else { + stringBuilder.setLength(zeroCount - 1); + register.stringValue = stringBuilder.toString(); + } + } + + @Override public String getValue() throws OverflowException { if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { throw new OverflowException("String is longer than allowed"); diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java index cbb34ffb..ba95095d 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java @@ -17,6 +17,8 @@ package com.exactpro.epfast.decoder.ascii; import com.exactpro.epfast.decoder.OverflowException; +import com.exactpro.epfast.decoder.message.DecoderState; +import com.exactpro.epfast.decoder.message.UnionRegister; public final class DecodeNullableAsciiString extends DecodeAsciiString { @@ -28,6 +30,30 @@ public DecodeNullableAsciiString(boolean checkOverlong) { super(checkOverlong); } + @Override + public void setRegisterValue(UnionRegister register) { + if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { + register.isOverflow = true; +// throw new OverflowException("String is longer than allowed"); + } + if (zeroCount < stringBuilder.length()) { + if (zeroPreamble && checkOverlong) { + register.isOverflow = true; +// throw new OverflowException("String with zero preamble can't contain any value except 0"); + } else { + register.stringValue = stringBuilder.toString(); + } + } else if (zeroCount == 1) { + register.stringValue = null; + } else if (zeroCount == 2) { + register.stringValue = ""; + } else { + stringBuilder.setLength(zeroCount - 2); + register.stringValue = stringBuilder.toString(); + } + } + + @Override public String getValue() throws OverflowException { if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { throw new OverflowException("String is longer than allowed"); diff --git a/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java b/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java index ed4d63d1..45778d1a 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java @@ -25,21 +25,13 @@ protected PrimitiveInstruction(T fieldDecoder) { super(fieldDecoder); } - protected void decode(DecoderState decoderState) throws OverflowException { + protected int decode(DecoderState decoderState) throws OverflowException { decoderStarted = true; - fieldDecoder.decode(decoderState.inputBuffer); - if (isReady()) { - setRegisterValue(decoderState); - decoderStarted = false; - } + return fieldDecoder.decode(decoderState.inputBuffer, decoderState); } - protected void continueDecode(DecoderState decoderState) throws OverflowException { - fieldDecoder.continueDecode(decoderState.inputBuffer); - if (isReady()) { - setRegisterValue(decoderState); - decoderStarted = false; - } + protected int continueDecode(DecoderState decoderState) throws OverflowException { + return fieldDecoder.continueDecode(decoderState.inputBuffer, decoderState); } public abstract void setRegisterValue(DecoderState decoderState) throws OverflowException; diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadMandatoryAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadMandatoryAsciiString.java index ceabcd8d..5bc1b8e8 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadMandatoryAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadMandatoryAsciiString.java @@ -28,6 +28,6 @@ public ReadMandatoryAsciiString() { } public void setRegisterValue(DecoderState decoderState) throws OverflowException { - decoderState.register.stringValue = fieldDecoder.getValue(); + //will be removed } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadNullableAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadNullableAsciiString.java index 72277d41..0cd5ae06 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadNullableAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadNullableAsciiString.java @@ -28,6 +28,6 @@ public ReadNullableAsciiString() { } public void setRegisterValue(DecoderState decoderState) throws OverflowException { - decoderState.register.stringValue = fieldDecoder.getValue(); + //will be removed } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryInt32.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryInt32.java index 2eb3409d..c9361fd2 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryInt32.java @@ -29,6 +29,7 @@ public ReadMandatoryInt32() { @Override public void setRegisterValue(DecoderState decoderState) throws OverflowException { - decoderState.register.mandatoryInt32Value = fieldDecoder.getValue(); + decoderState.register.int32Value = fieldDecoder.getValue(); + decoderState.register.isNull = false; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt32.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt32.java index a3dcaecf..c87c8109 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt32.java @@ -29,6 +29,7 @@ public ReadMandatoryUInt32() { @Override public void setRegisterValue(DecoderState decoderState) throws OverflowException { - decoderState.register.mandatoryUInt32Value = fieldDecoder.getValue(); + decoderState.register.uInt32Value = fieldDecoder.getValue(); + decoderState.register.isNull = false; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt32.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt32.java index d2825fa9..4c3dca9d 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt32.java @@ -28,6 +28,11 @@ public ReadNullableInt32() { } public void setRegisterValue(DecoderState decoderState) throws OverflowException { - decoderState.register.optionalInt32Value = fieldDecoder.getValue(); + if (fieldDecoder.getValue() == null) { + decoderState.register.isNull = true; + } else { + decoderState.register.int32Value = fieldDecoder.getValue(); + } + } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt32.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt32.java index b5fdb59d..804b3074 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt32.java @@ -27,6 +27,11 @@ public ReadNullableUInt32() { } public void setRegisterValue(DecoderState decoderState) throws OverflowException { - decoderState.register.optionalUInt32Value = fieldDecoder.getValue(); + if (fieldDecoder.getValue() == null) { + decoderState.register.isNull = true; + } else { + decoderState.register.uInt32Value = fieldDecoder.getValue(); + decoderState.register.isNull = false; + } } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/operators/AllOtherOperatorsMissingValue.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/operators/AllOtherOperatorsMissingValue.java index bd8fdd12..04299c84 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/operators/AllOtherOperatorsMissingValue.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/operators/AllOtherOperatorsMissingValue.java @@ -27,8 +27,7 @@ public int executeOn(DecoderState decoderState) { } private void tempOperatorLogic(DecoderState decoderState) { - decoderState.register.mandatoryInt32Value = -1; - decoderState.register.optionalInt32Value = -1; + decoderState.register.int32Value = -1; decoderState.register.stringValue = null; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/operators/DefaultMissingValue.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/operators/DefaultMissingValue.java index ef76fdcc..92caedeb 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/operators/DefaultMissingValue.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/operators/DefaultMissingValue.java @@ -29,8 +29,7 @@ public int executeOn(DecoderState decoderState) { } private void tempDefaultOperatorLogic(DecoderState decoderState) { - decoderState.register.mandatoryInt32Value = 1; - decoderState.register.optionalInt32Value = 1; + decoderState.register.int32Value = 1; decoderState.register.stringValue = "Default"; } diff --git a/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java b/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java index 41701498..7d4ff017 100644 --- a/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java +++ b/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java @@ -17,6 +17,7 @@ package com.exactpro.epfast.decoder.ascii; import com.exactpro.epfast.decoder.OverflowException; +import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; import org.junit.jupiter.api.Nested; From 5c82e27e2bbe6e60b9119ac0501b2a3311033b40 Mon Sep 17 00:00:00 2001 From: vdonadze Date: Fri, 31 Jul 2020 16:22:21 +0400 Subject: [PATCH 02/20] refactored decoders and tests --- .../epfast/decoder/IDecodeContext.java | 5 +- .../decoder/ascii/DecodeAsciiString.java | 12 +- .../ascii/DecodeMandatoryAsciiString.java | 36 +-- .../ascii/DecodeNullableAsciiString.java | 37 +-- .../epfast/decoder/decimal/DecodeDecimal.java | 10 +- .../decimal/DecodeMandatoryDecimal.java | 81 ++++--- .../decimal/DecodeNullableDecimal.java | 99 +++++--- .../epfast/decoder/integer/DecodeInteger.java | 7 +- .../decoder/integer/DecodeMandatoryInt32.java | 34 ++- .../decoder/integer/DecodeMandatoryInt64.java | 74 +++--- .../integer/DecodeMandatoryUInt32.java | 31 ++- .../integer/DecodeMandatoryUInt64.java | 31 ++- .../decoder/integer/DecodeNullableInt32.java | 38 ++- .../decoder/integer/DecodeNullableInt64.java | 38 ++- .../decoder/integer/DecodeNullableUInt32.java | 34 ++- .../decoder/integer/DecodeNullableUInt64.java | 35 ++- .../epfast/decoder/message/DecoderState.java | 28 --- .../epfast/decoder/message/FastCompiler.java | 2 + .../message/InstructionWithDecoder.java | 14 +- .../decoder/message/PrimitiveInstruction.java | 11 +- .../epfast/decoder/message/UnionRegister.java | 51 ++++ .../commands/SetMandatoryLengthField.java | 2 +- .../commands/SetNullableLengthField.java | 5 +- .../ascii/ReadMandatoryAsciiString.java | 6 - .../ascii/ReadNullableAsciiString.java | 5 - .../decimal/ReadMandatoryCompoundDecimal.java | 8 +- .../decimal/ReadMandatorySimpleDecimal.java | 7 - .../decimal/ReadNullableCompoundDecimal.java | 7 - .../decimal/ReadNullableSimpleDecimal.java | 7 - .../commands/integer/ReadMandatoryInt32.java | 8 - .../commands/integer/ReadMandatoryInt64.java | 6 - .../commands/integer/ReadMandatoryUInt32.java | 7 - .../commands/integer/ReadMandatoryUInt64.java | 6 - .../commands/integer/ReadNullableInt32.java | 11 - .../commands/integer/ReadNullableInt64.java | 7 - .../commands/integer/ReadNullableUInt32.java | 11 - .../commands/integer/ReadNullableUInt64.java | 7 - .../commands/integer/SetMandatoryInt32.java | 2 +- .../commands/integer/SetNullableInt32.java | 6 +- .../commands/presencemap/ReadPresenceMap.java | 5 - .../commands/presencemap/SetPresenceMap.java | 28 +++ .../unicode/ReadMandatoryByteVector.java | 7 - .../presencemap/DecodePresenceMap.java | 24 +- .../decoder/unicode/DecodeByteVector.java | 8 +- .../unicode/DecodeMandatoryByteVector.java | 44 ++-- .../unicode/DecodeNullableByteVector.java | 53 ++-- .../com/exactpro/epfast/DecoderUtils.java | 7 +- .../decoder/ascii/TestDecodeAsciiString.java | 124 +++++----- .../decoder/decimal/TestDecodeDecimal.java | 178 +++++++------- .../epfast/decoder/integer/TestInt32.java | 226 +++++++++--------- .../epfast/decoder/integer/TestInt64.java | 226 +++++++++--------- .../epfast/decoder/integer/TestUInt32.java | 128 +++++----- .../epfast/decoder/integer/TestUInt64.java | 134 ++++++----- .../presencemap/TestDecodePresenceMap.java | 15 +- .../decoder/unicode/TestDecodeByteVector.java | 86 +++---- 55 files changed, 1134 insertions(+), 985 deletions(-) create mode 100644 src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java create mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/presencemap/SetPresenceMap.java diff --git a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java index 90e79273..07a34309 100644 --- a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java +++ b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java @@ -16,7 +16,6 @@ package com.exactpro.epfast.decoder; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; @@ -24,9 +23,9 @@ public interface IDecodeContext { int CLEAR_STOP_BIT_MASK = 0b01111111; - int decode(ByteBuf buf, UnionRegister unionRegister); + int decode(ByteBuf buf, UnionRegister register); - int continueDecode(ByteBuf buf, UnionRegister unionRegister); + int continueDecode(ByteBuf buf, UnionRegister register); boolean isReady(); diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java index 92fb3c00..f2778a01 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java @@ -17,8 +17,6 @@ package com.exactpro.epfast.decoder.ascii; import com.exactpro.epfast.decoder.IDecodeContext; -import com.exactpro.epfast.decoder.OverflowException; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; @@ -40,7 +38,7 @@ public abstract class DecodeAsciiString implements IDecodeContext { this.checkOverlong = checkOverlong; } - public int decode(ByteBuf buf, UnionRegister unionRegister) { + public int decode(ByteBuf buf, UnionRegister register) { reset(); int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); @@ -53,14 +51,14 @@ public int decode(ByteBuf buf, UnionRegister unionRegister) { } buf.readerIndex(readerIndex); if (ready) { - setRegisterValue(unionRegister); + setRegisterValue(register); return 1; } else { return 0; } } - public int continueDecode(ByteBuf buf, UnionRegister unionRegister) { + public int continueDecode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); while ((readerIndex < readLimit) && !ready) { @@ -68,7 +66,7 @@ public int continueDecode(ByteBuf buf, UnionRegister unionRegister) { } buf.readerIndex(readerIndex); if (ready) { - setRegisterValue(unionRegister); + setRegisterValue(register); return 1; } else { return 0; @@ -77,8 +75,6 @@ public int continueDecode(ByteBuf buf, UnionRegister unionRegister) { public abstract void setRegisterValue(UnionRegister unionRegister); - public abstract String getValue() throws OverflowException; - public boolean isReady() { return ready; } diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java index 6f9e0a55..aa583461 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java @@ -16,8 +16,6 @@ package com.exactpro.epfast.decoder.ascii; -import com.exactpro.epfast.decoder.OverflowException; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.UnionRegister; public final class DecodeMandatoryAsciiString extends DecodeAsciiString { @@ -34,42 +32,26 @@ public DecodeMandatoryAsciiString(boolean checkOverlong) { public void setRegisterValue(UnionRegister register) { if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { register.isOverflow = true; - //TODO what to do with overflow information ? - //throw new OverflowException("String is longer than allowed"); - } - if (zeroCount < stringBuilder.length()) { + register.errorMessage = "String is longer than allowed"; + } else if (zeroCount < stringBuilder.length()) { if (zeroPreamble && checkOverlong) { - //TODO set register flag register.isOverflow = true; - //throw new OverflowException("String with zero preamble can't contain any value except 0"); + register.errorMessage = "String with zero preamble can't contain any value except 0"; } else { + register.isOverflow = false; + register.isNull = false; register.stringValue = stringBuilder.toString(); } } else if (zeroCount == 1) { + register.isOverflow = false; + register.isNull = false; register.stringValue = ""; } else { stringBuilder.setLength(zeroCount - 1); + register.isOverflow = false; + register.isNull = false; register.stringValue = stringBuilder.toString(); } } - - @Override - public String getValue() throws OverflowException { - if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { - throw new OverflowException("String is longer than allowed"); - } - if (zeroCount < stringBuilder.length()) { - if (zeroPreamble && checkOverlong) { - throw new OverflowException("String with zero preamble can't contain any value except 0"); - } else { - return stringBuilder.toString(); - } - } else if (zeroCount == 1) { - return ""; - } else { - stringBuilder.setLength(zeroCount - 1); - return stringBuilder.toString(); - } - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java index ba95095d..3b53901a 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java @@ -16,8 +16,6 @@ package com.exactpro.epfast.decoder.ascii; -import com.exactpro.epfast.decoder.OverflowException; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.UnionRegister; public final class DecodeNullableAsciiString extends DecodeAsciiString { @@ -34,43 +32,28 @@ public DecodeNullableAsciiString(boolean checkOverlong) { public void setRegisterValue(UnionRegister register) { if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { register.isOverflow = true; -// throw new OverflowException("String is longer than allowed"); - } - if (zeroCount < stringBuilder.length()) { + register.errorMessage = "String is longer than allowed"; + } else if (zeroCount < stringBuilder.length()) { if (zeroPreamble && checkOverlong) { register.isOverflow = true; -// throw new OverflowException("String with zero preamble can't contain any value except 0"); + register.errorMessage = "String with zero preamble can't contain any value except 0"; } else { + register.isOverflow = false; + register.isNull = false; register.stringValue = stringBuilder.toString(); } } else if (zeroCount == 1) { + register.isOverflow = false; register.stringValue = null; } else if (zeroCount == 2) { + register.isOverflow = false; + register.isNull = false; register.stringValue = ""; } else { stringBuilder.setLength(zeroCount - 2); + register.isOverflow = false; + register.isNull = false; register.stringValue = stringBuilder.toString(); } } - - @Override - public String getValue() throws OverflowException { - if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { - throw new OverflowException("String is longer than allowed"); - } - if (zeroCount < stringBuilder.length()) { - if (zeroPreamble && checkOverlong) { - throw new OverflowException("String with zero preamble can't contain any value except 0"); - } else { - return stringBuilder.toString(); - } - } else if (zeroCount == 1) { - return null; - } else if (zeroCount == 2) { - return ""; - } else { - stringBuilder.setLength(zeroCount - 2); - return stringBuilder.toString(); - } - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java index 04c5bccc..cc86f4f6 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java @@ -17,12 +17,10 @@ package com.exactpro.epfast.decoder.decimal; import com.exactpro.epfast.decoder.IDecodeContext; -import com.exactpro.epfast.decoder.OverflowException; import com.exactpro.epfast.decoder.integer.DecodeMandatoryInt64; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; -import java.math.BigDecimal; - public abstract class DecodeDecimal implements IDecodeContext { DecodeMandatoryInt64 mantissaDecoder = new DecodeMandatoryInt64(); @@ -39,9 +37,9 @@ public abstract class DecodeDecimal implements IDecodeContext { boolean mantissaOverflow; - public abstract void decode(ByteBuf buf); + public abstract int decode(ByteBuf buf, UnionRegister register); - public abstract void continueDecode(ByteBuf buf); + public abstract int continueDecode(ByteBuf buf, UnionRegister register); public final void reset() { exponentReady = false; @@ -51,7 +49,7 @@ public final void reset() { mantissaOverflow = false; } - public abstract BigDecimal getValue() throws OverflowException; + public abstract void setRegisterValue(UnionRegister register); public boolean isReady() { return ready; diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java index abc76b56..a4e1cc2c 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java @@ -16,8 +16,8 @@ package com.exactpro.epfast.decoder.decimal; -import com.exactpro.epfast.decoder.OverflowException; import com.exactpro.epfast.decoder.integer.DecodeMandatoryInt32; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; import java.math.BigDecimal; @@ -28,87 +28,104 @@ public final class DecodeMandatoryDecimal extends DecodeDecimal { private int exponent; - public void decode(ByteBuf buf) { + public int decode(ByteBuf buf, UnionRegister register) { reset(); - exponentDecoder.decode(buf); + exponentDecoder.decode(buf, register); if (exponentDecoder.isReady()) { exponentReady = true; - try { - exponent = exponentDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { exponentOverflow = true; + } else { + exponent = register.int32Value; } if (buf.isReadable()) { - mantissaDecoder.decode(buf); + mantissaDecoder.decode(buf, register); startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; - try { - mantissa = mantissaDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { mantissaOverflow = true; + } else { + mantissa = register.int64Value; } } } } + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public void continueDecode(ByteBuf buf) { + public int continueDecode(ByteBuf buf, UnionRegister register) { if (exponentReady && startedMantissa) { - mantissaDecoder.continueDecode(buf); + mantissaDecoder.continueDecode(buf, register); if (mantissaDecoder.isReady()) { ready = true; - try { - mantissa = mantissaDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { mantissaOverflow = true; + } else { + mantissa = register.int64Value; } } } else if (exponentReady) { - mantissaDecoder.decode(buf); + mantissaDecoder.decode(buf, register); startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; - try { - mantissa = mantissaDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { mantissaOverflow = true; + } else { + mantissa = register.int64Value; } } } else { - exponentDecoder.continueDecode(buf); + exponentDecoder.continueDecode(buf, register); if (exponentDecoder.isReady()) { exponentReady = true; - try { - exponent = exponentDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { exponentOverflow = true; + } else { + exponent = register.int32Value; } if (buf.isReadable()) { - mantissaDecoder.decode(buf); + mantissaDecoder.decode(buf, register); startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; - try { - mantissa = mantissaDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { mantissaOverflow = true; + } else { + mantissa = register.int64Value; } } } } } + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public BigDecimal getValue() throws OverflowException { + public void setRegisterValue(UnionRegister register) { if (exponentOverflow) { - throw new OverflowException("exponent value range is int32"); + register.isOverflow = true; + register.errorMessage = "exponent value range is int32"; } else if (mantissaOverflow) { - throw new OverflowException("mantissa value range is int64"); + register.isOverflow = true; + register.errorMessage = "mantissa value range is int64"; } else if (exponent >= -63 && exponent <= 63) { - return new BigDecimal(mantissa).movePointRight(exponent); + register.isOverflow = false; + register.isNull = false; + register.decimalValue = new BigDecimal(mantissa).movePointRight(exponent); } else { - throw new OverflowException("exponent value allowed range is -63 ... 63"); + register.isOverflow = true; + register.errorMessage = "exponent value allowed range is -63 ... 63"; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java index 75e567c6..fc849537 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java @@ -16,8 +16,8 @@ package com.exactpro.epfast.decoder.decimal; -import com.exactpro.epfast.decoder.OverflowException; import com.exactpro.epfast.decoder.integer.DecodeNullableInt32; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; import java.math.BigDecimal; @@ -26,99 +26,122 @@ public final class DecodeNullableDecimal extends DecodeDecimal { private DecodeNullableInt32 exponentDecoder = new DecodeNullableInt32(); - private Integer exponent; + private int exponent; private boolean nullValue; - public void decode(ByteBuf buf) { + public int decode(ByteBuf buf, UnionRegister register) { reset(); - exponentDecoder.decode(buf); + exponentDecoder.decode(buf, register); if (exponentDecoder.isReady()) { exponentReady = true; - try { - exponent = exponentDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { exponentOverflow = true; + } else { + exponent = register.int32Value; } - if (exponent != null && buf.isReadable()) { - mantissaDecoder.decode(buf); + if (!register.isNull && buf.isReadable()) { + mantissaDecoder.decode(buf, register); startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; - try { - mantissa = mantissaDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { mantissaOverflow = true; + } else { + mantissa = register.int64Value; } } - } else if (exponent == null) { + } else if (register.isNull) { nullValue = true; ready = true; + setRegisterValue(register); + return 1; } } + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public void continueDecode(ByteBuf buf) { + public int continueDecode(ByteBuf buf, UnionRegister register) { if (exponentReady && startedMantissa) { - mantissaDecoder.continueDecode(buf); + mantissaDecoder.continueDecode(buf, register); if (mantissaDecoder.isReady()) { ready = true; - try { - mantissa = mantissaDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { mantissaOverflow = true; + } else { + mantissa = register.int64Value; } } } else if (exponentReady) { startedMantissa = true; - mantissaDecoder.decode(buf); + mantissaDecoder.decode(buf, register); if (mantissaDecoder.isReady()) { ready = true; - try { - mantissa = mantissaDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { mantissaOverflow = true; + } else { + mantissa = register.int64Value; } } } else { - exponentDecoder.continueDecode(buf); + exponentDecoder.continueDecode(buf, register); if (exponentDecoder.isReady()) { exponentReady = true; - try { - exponent = exponentDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { exponentOverflow = true; + } else { + exponent = register.int32Value; } - if (exponent != null && buf.isReadable()) { - mantissaDecoder.decode(buf); + if (!register.isNull && buf.isReadable()) { + mantissaDecoder.decode(buf, register); startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; - try { - mantissa = mantissaDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { mantissaOverflow = true; + } else { + mantissa = register.int64Value; } } - } else if (exponent == null) { + } else if (register.isNull) { nullValue = true; ready = true; + setRegisterValue(register); + return 1; } } } + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public BigDecimal getValue() throws OverflowException { + @Override + public void setRegisterValue(UnionRegister register) { if (exponentOverflow) { - throw new OverflowException("exponent value range is int32"); + register.isOverflow = true; + register.errorMessage = "exponent value range is int32"; } else if (mantissaOverflow) { - throw new OverflowException("mantissa value range is int64"); + register.isOverflow = true; + register.errorMessage = "mantissa value range is int64"; } else if (nullValue) { - return null; + register.isOverflow = false; + register.decimalValue = null; } else if (exponent >= -63 && exponent <= 63) { - return new BigDecimal(mantissa).movePointRight(exponent); + register.isOverflow = false; + register.isNull = false; + register.decimalValue = new BigDecimal(mantissa).movePointRight(exponent); } else { - throw new OverflowException("exponent value allowed range is -63 ... 63"); + register.isOverflow = true; + register.errorMessage = "exponent value allowed range is -63 ... 63"; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java index b58bf253..849fca9c 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java @@ -17,6 +17,7 @@ package com.exactpro.epfast.decoder.integer; import com.exactpro.epfast.decoder.IDecodeContext; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; public abstract class DecodeInteger implements IDecodeContext { @@ -31,9 +32,9 @@ public abstract class DecodeInteger implements IDecodeContext { boolean checkForSignExtension = false; - public abstract void decode(ByteBuf buf); + public abstract int decode(ByteBuf buf, UnionRegister register); - public abstract void continueDecode(ByteBuf buf); + public abstract int continueDecode(ByteBuf buf, UnionRegister register); public boolean isReady() { return ready; @@ -56,4 +57,6 @@ static void longToBytes(long value, byte[] bytes) { value >>>= 8; } } + + public abstract void setRegisterValue(UnionRegister register); } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java index b6a9e5f5..48a5a3ca 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java @@ -16,7 +16,7 @@ package com.exactpro.epfast.decoder.integer; -import com.exactpro.epfast.decoder.OverflowException; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; public final class DecodeMandatoryInt32 extends DecodeInteger { @@ -27,7 +27,7 @@ public final class DecodeMandatoryInt32 extends DecodeInteger { private int value; - public void decode(ByteBuf buf) { + public int decode(ByteBuf buf, UnionRegister register) { reset(); int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); @@ -36,8 +36,9 @@ public void decode(ByteBuf buf) { value = 0; accumulatePositive(oneByte); if (oneByte < 0) { + setRegisterValue(register); buf.readerIndex(readerIndex); - return; + return 1; } if (readerIndex < readLimit) { checkOverlongPositive(buf.getByte(readerIndex)); //check second byte @@ -51,8 +52,9 @@ public void decode(ByteBuf buf) { value = -1; accumulateNegative(oneByte); if (oneByte < 0) { + setRegisterValue(register); buf.readerIndex(readerIndex); - return; + return 1; } if (readerIndex < readLimit) { checkOverlongNegative(buf.getByte(readerIndex)); //check second byte @@ -64,9 +66,15 @@ public void decode(ByteBuf buf) { } } buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public void continueDecode(ByteBuf buf) { + public int continueDecode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); if (value >= 0) { @@ -87,13 +95,23 @@ public void continueDecode(ByteBuf buf) { } while (!ready && readerIndex < readLimit); } buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public int getValue() throws OverflowException { + @Override + public void setRegisterValue(UnionRegister register) { if (overflow) { - throw new OverflowException("Int32 Overflow"); + register.isOverflow = true; + register.errorMessage = "Int32 Overflow"; } else { - return value; + register.isOverflow = false; + register.isNull = false; + register.int32Value = value; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java index 706e3cf1..244ba46f 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java @@ -16,7 +16,7 @@ package com.exactpro.epfast.decoder.integer; -import com.exactpro.epfast.decoder.OverflowException; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; public final class DecodeMandatoryInt64 extends DecodeInteger { @@ -27,7 +27,36 @@ public final class DecodeMandatoryInt64 extends DecodeInteger { private long value; - public void decode(ByteBuf buf) { + public int continueDecode(ByteBuf buf, UnionRegister register) { + int readerIndex = buf.readerIndex(); + int readLimit = buf.writerIndex(); + if (value >= 0) { + if (checkForSignExtension) { + checkOverlongPositive(buf.getByte(readerIndex)); //continue checking + checkForSignExtension = false; + } + do { + accumulatePositive(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } else { + if (checkForSignExtension) { + checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes + checkForSignExtension = false; + } + do { + accumulateNegative(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } + buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } + } + + public int decode(ByteBuf buf, UnionRegister register) { reset(); int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); @@ -36,8 +65,9 @@ public void decode(ByteBuf buf) { value = 0; accumulatePositive(oneByte); if (oneByte < 0) { + setRegisterValue(register); buf.readerIndex(readerIndex); - return; + return 1; } if (readerIndex < readLimit) { checkOverlongPositive(buf.getByte(readerIndex)); //check second byte @@ -51,8 +81,9 @@ public void decode(ByteBuf buf) { value = -1; accumulateNegative(oneByte); if (oneByte < 0) { + setRegisterValue(register); buf.readerIndex(readerIndex); - return; + return 1; } if (readerIndex < readLimit) { checkOverlongNegative(buf.getByte(readerIndex)); //check second byte @@ -64,36 +95,23 @@ public void decode(ByteBuf buf) { } } buf.readerIndex(readerIndex); - } - - public void continueDecode(ByteBuf buf) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (value >= 0) { - if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex)); //continue checking - checkForSignExtension = false; - } - do { - accumulatePositive(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + if (ready) { + setRegisterValue(register); + return 1; } else { - if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes - checkForSignExtension = false; - } - do { - accumulateNegative(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + return 0; } - buf.readerIndex(readerIndex); } - public long getValue() throws OverflowException { + @Override + public void setRegisterValue(UnionRegister register) { if (overflow) { - throw new OverflowException("Int64 Overflow"); + register.isOverflow = true; + register.errorMessage = "Int64 Overflow"; } else { - return value; + register.isOverflow = false; + register.isNull = false; + register.int64Value = value; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java index c0434341..4b08dee5 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java @@ -16,7 +16,7 @@ package com.exactpro.epfast.decoder.integer; -import com.exactpro.epfast.decoder.OverflowException; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; public final class DecodeMandatoryUInt32 extends DecodeInteger { @@ -25,7 +25,7 @@ public final class DecodeMandatoryUInt32 extends DecodeInteger { private int value; - public void decode(ByteBuf buf) { + public int decode(ByteBuf buf, UnionRegister register) { reset(); value = 0; int readerIndex = buf.readerIndex(); @@ -33,8 +33,9 @@ public void decode(ByteBuf buf) { int oneByte = buf.getByte(readerIndex++); accumulate(oneByte); if (oneByte < 0) { + setRegisterValue(register); buf.readerIndex(readerIndex); - return; + return 1; } if (readerIndex < readLimit) { checkOverlong(buf.getByte(readerIndex)); //check second byte @@ -45,9 +46,15 @@ public void decode(ByteBuf buf) { checkForSignExtension = true; } buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public void continueDecode(ByteBuf buf) { + public int continueDecode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); if (checkForSignExtension) { @@ -58,13 +65,23 @@ public void continueDecode(ByteBuf buf) { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public long getValue() throws OverflowException { + @Override + public void setRegisterValue(UnionRegister register) { if (overflow) { - throw new OverflowException("UInt32 Overflow"); + register.isOverflow = true; + register.errorMessage = "UInt32 Overflow"; } else { - return value & 0x0_FFFFFFFFL; + register.isOverflow = false; + register.isNull = false; + register.uInt32Value = value & 0x0_FFFFFFFFL; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java index 79eb9b8f..6c67c5a4 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java @@ -16,7 +16,7 @@ package com.exactpro.epfast.decoder.integer; -import com.exactpro.epfast.decoder.OverflowException; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; import java.math.BigInteger; @@ -29,7 +29,7 @@ public final class DecodeMandatoryUInt64 extends DecodeInteger { private long value; - public void decode(ByteBuf buf) { + public int decode(ByteBuf buf, UnionRegister register) { reset(); value = 0; int readerIndex = buf.readerIndex(); @@ -37,8 +37,9 @@ public void decode(ByteBuf buf) { int oneByte = buf.getByte(readerIndex++); accumulate(oneByte); if (oneByte < 0) { + setRegisterValue(register); buf.readerIndex(readerIndex); - return; + return 1; } if (readerIndex < readLimit) { checkOverlong(buf.getByte(readerIndex)); //check second byte @@ -49,9 +50,15 @@ public void decode(ByteBuf buf) { checkForSignExtension = true; } buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public void continueDecode(ByteBuf buf) { + public int continueDecode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); if (checkForSignExtension) { @@ -62,14 +69,24 @@ public void continueDecode(ByteBuf buf) { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public BigInteger getValue() throws OverflowException { + @Override + public void setRegisterValue(UnionRegister register) { if (overflow) { - throw new OverflowException("UInt32 Overflow"); + register.isOverflow = true; + register.errorMessage = "UInt32 Overflow"; } else { longToBytes(value, bytes); - return new BigInteger(1, bytes); + register.isOverflow = false; + register.isNull = false; + register.unsignedInt64Value = new BigInteger(1, bytes); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java index 2620f426..ffa719a9 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java @@ -16,7 +16,7 @@ package com.exactpro.epfast.decoder.integer; -import com.exactpro.epfast.decoder.OverflowException; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; public final class DecodeNullableInt32 extends DecodeInteger { @@ -29,7 +29,7 @@ public final class DecodeNullableInt32 extends DecodeInteger { private int value; - public void decode(ByteBuf buf) { + public int decode(ByteBuf buf, UnionRegister register) { reset(); int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); @@ -39,8 +39,9 @@ public void decode(ByteBuf buf) { value = 0; accumulatePositive(oneByte); if (oneByte < 0) { + setRegisterValue(register); buf.readerIndex(readerIndex); - return; + return 1; } if (readerIndex < readLimit) { checkOverlongPositive(buf.getByte(readerIndex)); //check second byte @@ -55,8 +56,9 @@ public void decode(ByteBuf buf) { value = -1; accumulateNegative(oneByte); if (oneByte < 0) { + setRegisterValue(register); buf.readerIndex(readerIndex); - return; + return 1; } if (readerIndex < readLimit) { checkOverlongNegative(buf.getByte(readerIndex)); //check second byte @@ -68,9 +70,15 @@ public void decode(ByteBuf buf) { } } buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public void continueDecode(ByteBuf buf) { + public int continueDecode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); if (value >= 0) { @@ -91,13 +99,27 @@ public void continueDecode(ByteBuf buf) { } while (!ready && readerIndex < readLimit); } buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public Integer getValue() throws OverflowException { + @Override + public void setRegisterValue(UnionRegister register) { if (overflow) { - throw new OverflowException("Int32 Overflow"); + register.isOverflow = true; + register.errorMessage = "Int32 Overflow"; } else { - return value == 0 ? null : positive ? value - 1 : value; + register.isOverflow = false; + if (value == 0) { + register.isNull = true; + } else { + register.isNull = false; + register.int32Value = positive ? value - 1 : value; + } } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java index 7aa33915..a0c168ef 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java @@ -16,7 +16,7 @@ package com.exactpro.epfast.decoder.integer; -import com.exactpro.epfast.decoder.OverflowException; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; public final class DecodeNullableInt64 extends DecodeInteger { @@ -29,7 +29,7 @@ public final class DecodeNullableInt64 extends DecodeInteger { private long value; - public void decode(ByteBuf buf) { + public int decode(ByteBuf buf, UnionRegister register) { reset(); int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); @@ -39,8 +39,9 @@ public void decode(ByteBuf buf) { value = 0; accumulatePositive(oneByte); if (oneByte < 0) { + setRegisterValue(register); buf.readerIndex(readerIndex); - return; + return 1; } if (readerIndex < readLimit) { checkOverlongPositive(buf.getByte(readerIndex)); //check second byte @@ -55,8 +56,9 @@ public void decode(ByteBuf buf) { value = -1; accumulateNegative(oneByte); if (oneByte < 0) { + setRegisterValue(register); buf.readerIndex(readerIndex); - return; + return 1; } if (readerIndex < readLimit) { checkOverlongNegative(buf.getByte(readerIndex)); //check second byte @@ -68,9 +70,15 @@ public void decode(ByteBuf buf) { } } buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public void continueDecode(ByteBuf buf) { + public int continueDecode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); if (value >= 0) { @@ -91,13 +99,27 @@ public void continueDecode(ByteBuf buf) { } while (!ready && readerIndex < readLimit); } buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public Long getValue() throws OverflowException { + @Override + public void setRegisterValue(UnionRegister register) { if (overflow) { - throw new OverflowException("Int64 Overflow"); + register.isOverflow = true; + register.errorMessage = "Int64 Overflow"; } else { - return value == 0 ? null : positive ? value - 1 : value; + register.isOverflow = false; + if (value == 0) { + register.isNull = true; + } else { + register.isNull = false; + register.int64Value = positive ? value - 1 : value; + } } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java index f71f7e52..cf99d142 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java @@ -16,7 +16,7 @@ package com.exactpro.epfast.decoder.integer; -import com.exactpro.epfast.decoder.OverflowException; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; public final class DecodeNullableUInt32 extends DecodeInteger { @@ -27,7 +27,7 @@ public final class DecodeNullableUInt32 extends DecodeInteger { private int value; - public void decode(ByteBuf buf) { + public int decode(ByteBuf buf, UnionRegister register) { reset(); value = 0; isUInt32Limit = false; @@ -36,8 +36,9 @@ public void decode(ByteBuf buf) { int oneByte = buf.getByte(readerIndex++); accumulate(oneByte); if (oneByte < 0) { + setRegisterValue(register); buf.readerIndex(readerIndex); - return; + return 1; } if (readerIndex < readLimit) { checkOverlong(buf.getByte(readerIndex)); //check second byte @@ -48,9 +49,15 @@ public void decode(ByteBuf buf) { checkForSignExtension = true; } buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public void continueDecode(ByteBuf buf) { + public int continueDecode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); if (checkForSignExtension) { @@ -61,15 +68,26 @@ public void continueDecode(ByteBuf buf) { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public Long getValue() throws OverflowException { + @Override + public void setRegisterValue(UnionRegister register) { if (overflow) { - throw new OverflowException("UInt32 Overflow"); + register.isOverflow = true; + register.errorMessage = "UInt32 Overflow"; } else if (value == 0) { - return null; + register.isOverflow = false; + register.isNull = true; } else { - return isUInt32Limit ? 0x0_FFFFFFFFL : value - 1 & 0x0_FFFFFFFFL; + register.isOverflow = false; + register.isNull = false; + register.uInt32Value = isUInt32Limit ? 0x0_FFFFFFFFL : value - 1 & 0x0_FFFFFFFFL; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java index 51f2a63c..ffd441d6 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java @@ -16,7 +16,7 @@ package com.exactpro.epfast.decoder.integer; -import com.exactpro.epfast.decoder.OverflowException; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; import java.math.BigInteger; @@ -31,7 +31,7 @@ public final class DecodeNullableUInt64 extends DecodeInteger { private long value; - public void decode(ByteBuf buf) { + public int decode(ByteBuf buf, UnionRegister register) { reset(); value = 0; isUInt64Limit = false; @@ -40,8 +40,9 @@ public void decode(ByteBuf buf) { int oneByte = buf.getByte(readerIndex++); accumulate(oneByte); if (oneByte < 0) { + setRegisterValue(register); buf.readerIndex(readerIndex); - return; + return 1; } if (readerIndex < readLimit) { checkOverlong(buf.getByte(readerIndex)); //check second byte @@ -52,9 +53,15 @@ public void decode(ByteBuf buf) { checkForSignExtension = true; } buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public void continueDecode(ByteBuf buf) { + public int continueDecode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); if (checkForSignExtension) { @@ -65,21 +72,31 @@ public void continueDecode(ByteBuf buf) { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public BigInteger getValue() throws OverflowException { + @Override + public void setRegisterValue(UnionRegister register) { if (overflow) { - throw new OverflowException("UInt64 Overflow"); + register.isOverflow = true; + register.errorMessage = "UInt64 Overflow"; } else if (value == 0) { - return null; + register.isOverflow = false; + register.isNull = true; } else { + register.isOverflow = false; + register.isNull = false; if (isUInt64Limit) { longToBytes(-1L, bytes); - return new BigInteger(1, bytes); } else { longToBytes(value - 1, bytes); - return new BigInteger(1, bytes); } + register.unsignedInt64Value = new BigInteger(1, bytes); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/DecoderState.java b/src/main/java/com/exactpro/epfast/decoder/message/DecoderState.java index f4ef9422..70fbd740 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/DecoderState.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/DecoderState.java @@ -21,8 +21,6 @@ import com.exactpro.epfast.template.*; import io.netty.buffer.ByteBuf; -import java.math.BigDecimal; -import java.math.BigInteger; import java.util.*; public class DecoderState { @@ -79,32 +77,6 @@ public Collection readMessages() { return messages; } - // Logically it's one register. It's up to application to ensure that the right field is used for read / write. - public static class UnionRegister { - - // public boolean isNull; - - public int mandatoryInt32Value; - - public Integer optionalInt32Value; - - public Long optionalUInt32Value; - - public long mandatoryUInt32Value; - - public String stringValue; - - public long mandatoryInt64Value; - - public Long optionalInt64Value; - - public BigInteger unsignedInt64Value; - - public BigDecimal decimalValue; - - public Object applicationValue; - } - public static class CallStackFrame { private final PresenceMap presenceMap; diff --git a/src/main/java/com/exactpro/epfast/decoder/message/FastCompiler.java b/src/main/java/com/exactpro/epfast/decoder/message/FastCompiler.java index bf9ac08d..6dad87e4 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/FastCompiler.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/FastCompiler.java @@ -28,6 +28,7 @@ import com.exactpro.epfast.decoder.message.commands.operators.DefaultPresentValue; import com.exactpro.epfast.decoder.message.commands.presencemap.CheckPresenceBit; import com.exactpro.epfast.decoder.message.commands.presencemap.ReadPresenceMap; +import com.exactpro.epfast.decoder.message.commands.presencemap.SetPresenceMap; import com.exactpro.epfast.template.*; import java.util.*; @@ -64,6 +65,7 @@ private void compile( } if (requiresPresenceMap(instructions)) { commandSet.add(new ReadPresenceMap()); + commandSet.add(new SetPresenceMap()); } for (Instruction instruction : instructions) { if (instruction instanceof Group) { diff --git a/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java b/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java index 7760db8b..6200e2e6 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java @@ -31,9 +31,9 @@ protected InstructionWithDecoder(T fieldDecoder) { this.fieldDecoder = Objects.requireNonNull(fieldDecoder); } - protected abstract void decode(DecoderState decoderState) throws OverflowException; + protected abstract int decode(DecoderState decoderState) throws OverflowException; - protected abstract void continueDecode(DecoderState decoderState) throws OverflowException; + protected abstract int continueDecode(DecoderState decoderState) throws OverflowException; public boolean isReady() { return fieldDecoder.isReady(); @@ -46,15 +46,9 @@ public int executeOn(DecoderState decoderState) throws OverflowException { return 0; } if (!decoderStarted) { - decode(decoderState); + return decode(decoderState); } else { - continueDecode(decoderState); - } - if (isReady()) { - return 1; - } else { - decoderState.canProceed = false; - return 0; + return continueDecode(decoderState); } } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java b/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java index 45778d1a..87b3fa3c 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java @@ -17,7 +17,6 @@ package com.exactpro.epfast.decoder.message; import com.exactpro.epfast.decoder.IDecodeContext; -import com.exactpro.epfast.decoder.OverflowException; public abstract class PrimitiveInstruction extends InstructionWithDecoder { @@ -25,14 +24,12 @@ protected PrimitiveInstruction(T fieldDecoder) { super(fieldDecoder); } - protected int decode(DecoderState decoderState) throws OverflowException { + protected int decode(DecoderState decoderState) { decoderStarted = true; - return fieldDecoder.decode(decoderState.inputBuffer, decoderState); + return fieldDecoder.decode(decoderState.inputBuffer, decoderState.register); } - protected int continueDecode(DecoderState decoderState) throws OverflowException { - return fieldDecoder.continueDecode(decoderState.inputBuffer, decoderState); + protected int continueDecode(DecoderState decoderState) { + return fieldDecoder.continueDecode(decoderState.inputBuffer, decoderState.register); } - - public abstract void setRegisterValue(DecoderState decoderState) throws OverflowException; } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java b/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java new file mode 100644 index 00000000..ad8baf14 --- /dev/null +++ b/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java @@ -0,0 +1,51 @@ +/* + * Copyright 2020 Exactpro (Exactpro Systems Limited) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.exactpro.epfast.decoder.message; + +import com.exactpro.epfast.decoder.presencemap.PresenceMap; + +import java.math.BigDecimal; +import java.math.BigInteger; + +// Logically it's one register. It's up to application to ensure that the right field is used for read / write. +public class UnionRegister { + + public boolean isNull; + + public boolean isOverflow; + + public int int32Value; + + public long uInt32Value; + + public String stringValue; + + public long int64Value; + + public BigInteger unsignedInt64Value; + + public BigDecimal decimalValue; + + public byte[] byteVectorValue; + + public Object applicationValue; + + public String errorMessage; + + public PresenceMap presenceMap; +} + diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/SetMandatoryLengthField.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/SetMandatoryLengthField.java index 4f6ac10a..5460b16c 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/SetMandatoryLengthField.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/SetMandatoryLengthField.java @@ -22,7 +22,7 @@ public class SetMandatoryLengthField implements DecoderCommand { @Override public int executeOn(DecoderState decoderState) { - decoderState.loopLimit = decoderState.register.mandatoryUInt32Value; + decoderState.loopLimit = decoderState.register.uInt32Value; return 1; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/SetNullableLengthField.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/SetNullableLengthField.java index bd5c4f4c..ebfb230b 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/SetNullableLengthField.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/SetNullableLengthField.java @@ -23,9 +23,8 @@ public class SetNullableLengthField implements DecoderCommand { @Override public int executeOn(DecoderState decoderState) { - Long lengthValue = decoderState.register.optionalUInt32Value; - if (lengthValue != null) { - decoderState.loopLimit = lengthValue; + if (!decoderState.register.isNull) { + decoderState.loopLimit = decoderState.register.uInt32Value; } else { decoderState.loopLimit = -1; } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadMandatoryAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadMandatoryAsciiString.java index 5bc1b8e8..e0c78631 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadMandatoryAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadMandatoryAsciiString.java @@ -16,9 +16,7 @@ package com.exactpro.epfast.decoder.message.commands.ascii; -import com.exactpro.epfast.decoder.OverflowException; import com.exactpro.epfast.decoder.ascii.DecodeMandatoryAsciiString; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.PrimitiveInstruction; public class ReadMandatoryAsciiString extends PrimitiveInstruction { @@ -26,8 +24,4 @@ public class ReadMandatoryAsciiString extends PrimitiveInstruction { @@ -27,7 +25,4 @@ public ReadNullableAsciiString() { super(new DecodeNullableAsciiString()); } - public void setRegisterValue(DecoderState decoderState) throws OverflowException { - //will be removed - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatoryCompoundDecimal.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatoryCompoundDecimal.java index 378cec7d..e4e7ae93 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatoryCompoundDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatoryCompoundDecimal.java @@ -16,18 +16,12 @@ package com.exactpro.epfast.decoder.message.commands.decimal; -import com.exactpro.epfast.decoder.OverflowException; import com.exactpro.epfast.decoder.decimal.DecodeMandatoryDecimal; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.PrimitiveInstruction; public class ReadMandatoryCompoundDecimal extends PrimitiveInstruction { public ReadMandatoryCompoundDecimal() { - super(new DecodeMandatoryDecimal()); } - - @Override - public void setRegisterValue(DecoderState decoderState) throws OverflowException { - throw new UnsupportedOperationException(); + super(new DecodeMandatoryDecimal()); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatorySimpleDecimal.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatorySimpleDecimal.java index 2e2aba37..b9bbb370 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatorySimpleDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatorySimpleDecimal.java @@ -16,18 +16,11 @@ package com.exactpro.epfast.decoder.message.commands.decimal; -import com.exactpro.epfast.decoder.OverflowException; import com.exactpro.epfast.decoder.decimal.DecodeMandatoryDecimal; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.PrimitiveInstruction; public class ReadMandatorySimpleDecimal extends PrimitiveInstruction { public ReadMandatorySimpleDecimal() { super(new DecodeMandatoryDecimal()); } - - @Override - public void setRegisterValue(DecoderState decoderState) throws OverflowException { - throw new UnsupportedOperationException(); - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadNullableCompoundDecimal.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadNullableCompoundDecimal.java index cc1025ef..79b77c5f 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadNullableCompoundDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadNullableCompoundDecimal.java @@ -16,9 +16,7 @@ package com.exactpro.epfast.decoder.message.commands.decimal; -import com.exactpro.epfast.decoder.OverflowException; import com.exactpro.epfast.decoder.decimal.DecodeNullableDecimal; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.PrimitiveInstruction; public class ReadNullableCompoundDecimal extends PrimitiveInstruction { @@ -26,9 +24,4 @@ public class ReadNullableCompoundDecimal extends PrimitiveInstruction { @@ -26,9 +24,4 @@ public class ReadNullableSimpleDecimal extends PrimitiveInstruction { @@ -26,10 +24,4 @@ public class ReadMandatoryInt32 extends PrimitiveInstruction { @@ -26,8 +24,4 @@ public ReadMandatoryInt64() { super(new DecodeMandatoryInt64()); } - @Override - public void setRegisterValue(DecoderState decoderState) throws OverflowException { - throw new UnsupportedOperationException(); - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt32.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt32.java index c87c8109..85788cf5 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt32.java @@ -16,9 +16,7 @@ package com.exactpro.epfast.decoder.message.commands.integer; -import com.exactpro.epfast.decoder.OverflowException; import com.exactpro.epfast.decoder.integer.DecodeMandatoryUInt32; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.PrimitiveInstruction; public class ReadMandatoryUInt32 extends PrimitiveInstruction { @@ -27,9 +25,4 @@ public ReadMandatoryUInt32() { super(new DecodeMandatoryUInt32()); } - @Override - public void setRegisterValue(DecoderState decoderState) throws OverflowException { - decoderState.register.uInt32Value = fieldDecoder.getValue(); - decoderState.register.isNull = false; - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt64.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt64.java index 30b0cf16..967f332e 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt64.java @@ -16,9 +16,7 @@ package com.exactpro.epfast.decoder.message.commands.integer; -import com.exactpro.epfast.decoder.OverflowException; import com.exactpro.epfast.decoder.integer.DecodeMandatoryUInt64; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.PrimitiveInstruction; public class ReadMandatoryUInt64 extends PrimitiveInstruction { @@ -27,8 +25,4 @@ public ReadMandatoryUInt64() { super(new DecodeMandatoryUInt64()); } - @Override - public void setRegisterValue(DecoderState decoderState) throws OverflowException { - throw new UnsupportedOperationException(); - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt32.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt32.java index 4c3dca9d..6ff7e878 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt32.java @@ -17,8 +17,6 @@ package com.exactpro.epfast.decoder.message.commands.integer; import com.exactpro.epfast.decoder.integer.DecodeNullableInt32; -import com.exactpro.epfast.decoder.OverflowException; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.PrimitiveInstruction; public class ReadNullableInt32 extends PrimitiveInstruction { @@ -26,13 +24,4 @@ public class ReadNullableInt32 extends PrimitiveInstruction public ReadNullableInt32() { super(new DecodeNullableInt32()); } - - public void setRegisterValue(DecoderState decoderState) throws OverflowException { - if (fieldDecoder.getValue() == null) { - decoderState.register.isNull = true; - } else { - decoderState.register.int32Value = fieldDecoder.getValue(); - } - - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt64.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt64.java index f3dde71e..cf897fe1 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt64.java @@ -16,9 +16,7 @@ package com.exactpro.epfast.decoder.message.commands.integer; -import com.exactpro.epfast.decoder.OverflowException; import com.exactpro.epfast.decoder.integer.DecodeNullableInt64; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.PrimitiveInstruction; public class ReadNullableInt64 extends PrimitiveInstruction { @@ -26,9 +24,4 @@ public class ReadNullableInt64 extends PrimitiveInstruction public ReadNullableInt64() { super(new DecodeNullableInt64()); } - - @Override - public void setRegisterValue(DecoderState decoderState) throws OverflowException { - throw new UnsupportedOperationException(); - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt32.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt32.java index 804b3074..7cacedaf 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt32.java @@ -16,22 +16,11 @@ package com.exactpro.epfast.decoder.message.commands.integer; -import com.exactpro.epfast.decoder.OverflowException; import com.exactpro.epfast.decoder.integer.DecodeNullableUInt32; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.PrimitiveInstruction; public class ReadNullableUInt32 extends PrimitiveInstruction { public ReadNullableUInt32() { super(new DecodeNullableUInt32()); } - - public void setRegisterValue(DecoderState decoderState) throws OverflowException { - if (fieldDecoder.getValue() == null) { - decoderState.register.isNull = true; - } else { - decoderState.register.uInt32Value = fieldDecoder.getValue(); - decoderState.register.isNull = false; - } - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt64.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt64.java index a1d31f2f..63e29542 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt64.java @@ -16,18 +16,11 @@ package com.exactpro.epfast.decoder.message.commands.integer; -import com.exactpro.epfast.decoder.OverflowException; import com.exactpro.epfast.decoder.integer.DecodeNullableUInt64; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.PrimitiveInstruction; public class ReadNullableUInt64 extends PrimitiveInstruction { public ReadNullableUInt64() { super(new DecodeNullableUInt64()); } - - @Override - public void setRegisterValue(DecoderState decoderState) throws OverflowException { - throw new UnsupportedOperationException(); - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/SetMandatoryInt32.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/SetMandatoryInt32.java index f3a36858..f8c52061 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/SetMandatoryInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/SetMandatoryInt32.java @@ -30,7 +30,7 @@ public SetMandatoryInt32(Reference propertyId) { @Override public int executeOn(DecoderState decoderState) { - decoderState.activeMessage.setField(propertyId, decoderState.register.mandatoryInt32Value); + decoderState.activeMessage.setField(propertyId, decoderState.register.int32Value); return 1; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/SetNullableInt32.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/SetNullableInt32.java index a4ca8dd1..e1c61abc 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/SetNullableInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/SetNullableInt32.java @@ -30,7 +30,11 @@ public SetNullableInt32(Reference propertyId) { @Override public int executeOn(DecoderState decoderState) { - decoderState.activeMessage.setField(propertyId, decoderState.register.optionalInt32Value); + if (decoderState.register.isNull) { + decoderState.activeMessage.setField(propertyId, null); + } else { + decoderState.activeMessage.setField(propertyId, decoderState.register.int32Value); + } return 1; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/presencemap/ReadPresenceMap.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/presencemap/ReadPresenceMap.java index 1f0a3255..c1be37fe 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/presencemap/ReadPresenceMap.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/presencemap/ReadPresenceMap.java @@ -16,7 +16,6 @@ package com.exactpro.epfast.decoder.message.commands.presencemap; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.PrimitiveInstruction; import com.exactpro.epfast.decoder.presencemap.DecodePresenceMap; @@ -26,8 +25,4 @@ public ReadPresenceMap() { super(new DecodePresenceMap()); } - @Override - public void setRegisterValue(DecoderState decoderState) { - decoderState.presenceMap = fieldDecoder.getValue(); - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/presencemap/SetPresenceMap.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/presencemap/SetPresenceMap.java new file mode 100644 index 00000000..e17c1189 --- /dev/null +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/presencemap/SetPresenceMap.java @@ -0,0 +1,28 @@ +/* + * Copyright 2020 Exactpro (Exactpro Systems Limited) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.exactpro.epfast.decoder.message.commands.presencemap; + +import com.exactpro.epfast.decoder.message.DecoderCommand; +import com.exactpro.epfast.decoder.message.DecoderState; + +public class SetPresenceMap implements DecoderCommand { + @Override + public int executeOn(DecoderState decoderState) { + decoderState.presenceMap = decoderState.register.presenceMap; + return 1; + } +} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/unicode/ReadMandatoryByteVector.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/unicode/ReadMandatoryByteVector.java index 1a8ffc6e..796d46b3 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/unicode/ReadMandatoryByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/commands/unicode/ReadMandatoryByteVector.java @@ -16,8 +16,6 @@ package com.exactpro.epfast.decoder.message.commands.unicode; -import com.exactpro.epfast.decoder.OverflowException; -import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.PrimitiveInstruction; import com.exactpro.epfast.decoder.unicode.DecodeMandatoryByteVector; @@ -26,9 +24,4 @@ public class ReadMandatoryByteVector extends PrimitiveInstruction 0) { int readerIndex = buf.readerIndex(); @@ -53,9 +53,15 @@ public void decode(ByteBuf buf) { ready = true; } } + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public void continueDecode(ByteBuf buf) { + public int continueDecode(ByteBuf buf, UnionRegister register) { if (lengthReady) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); @@ -70,13 +76,13 @@ public void continueDecode(ByteBuf buf) { } buf.readerIndex(readerIndex); } else { - lengthDecoder.continueDecode(buf); + lengthDecoder.continueDecode(buf, register); if (lengthDecoder.isReady()) { lengthReady = true; - try { - messageLength = lengthDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { overflow = true; + } else { + messageLength = register.uInt32Value; } if (messageLength > 0) { int readerIndex = buf.readerIndex(); @@ -96,17 +102,27 @@ public void continueDecode(ByteBuf buf) { } } } + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public byte[] getValue() throws OverflowException { + @Override + public void setRegisterValue(UnionRegister register) { if (overflow) { - throw new OverflowException("length value range is uint32"); + register.isOverflow = true; + register.errorMessage = "length value range is uint32"; } else { byte[] finalVal = new byte[value.size()]; for (int i = 0; i < value.size(); i++) { finalVal[i] = value.get(i); } - return finalVal; + register.isOverflow = false; + register.isNull = false; + register.byteVectorValue = finalVal; } } } diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java index 8e3c54e5..2959be27 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java @@ -16,27 +16,27 @@ package com.exactpro.epfast.decoder.unicode; -import com.exactpro.epfast.decoder.OverflowException; import com.exactpro.epfast.decoder.integer.DecodeNullableUInt32; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; public final class DecodeNullableByteVector extends DecodeByteVector { private DecodeNullableUInt32 lengthDecoder = new DecodeNullableUInt32(); - private Long messageLength; + private long messageLength; - public void decode(ByteBuf buf) { + public int decode(ByteBuf buf, UnionRegister register) { reset(); - lengthDecoder.decode(buf); + lengthDecoder.decode(buf, register); if (lengthDecoder.isReady()) { lengthReady = true; - try { - messageLength = lengthDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { overflow = true; + } else { + messageLength = register.uInt32Value; } - if (messageLength != null && messageLength > 0) { + if (!register.isNull && messageLength > 0) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); while ((readerIndex < readLimit) && !ready) { @@ -53,9 +53,15 @@ public void decode(ByteBuf buf) { ready = true; } } + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public void continueDecode(ByteBuf buf) { + public int continueDecode(ByteBuf buf, UnionRegister register) { if (lengthReady) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); @@ -70,15 +76,15 @@ public void continueDecode(ByteBuf buf) { } buf.readerIndex(readerIndex); } else { - lengthDecoder.continueDecode(buf); + lengthDecoder.continueDecode(buf, register); if (lengthDecoder.isReady()) { lengthReady = true; - try { - messageLength = lengthDecoder.getValue(); - } catch (OverflowException ex) { + if (register.isOverflow) { overflow = true; + } else { + messageLength = register.uInt32Value; } - if (messageLength != null && messageLength > 0) { + if (!register.isNull && messageLength > 0) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); while ((readerIndex < readLimit) && !ready) { @@ -96,17 +102,30 @@ public void continueDecode(ByteBuf buf) { } } } + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } } - public byte[] getValue() throws OverflowException { + @Override + public void setRegisterValue(UnionRegister register) { if (overflow) { - throw new OverflowException("length value range is uint32"); + register.isOverflow = true; + register.errorMessage = "length value range is uint32"; } else { byte[] finalVal = new byte[value.size()]; for (int i = 0; i < value.size(); i++) { finalVal[i] = value.get(i); } - return messageLength == null ? null : finalVal; + register.isOverflow = false; + if (register.isNull) { + register.byteVectorValue = null; + } else { + register.byteVectorValue = finalVal; + } } } } diff --git a/src/test/java/com/exactpro/epfast/DecoderUtils.java b/src/test/java/com/exactpro/epfast/DecoderUtils.java index f5efaed1..df91506b 100644 --- a/src/test/java/com/exactpro/epfast/DecoderUtils.java +++ b/src/test/java/com/exactpro/epfast/DecoderUtils.java @@ -17,17 +17,18 @@ package com.exactpro.epfast; import com.exactpro.epfast.decoder.IDecodeContext; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; import java.util.Iterator; public class DecoderUtils { - public static void decode(IDecodeContext decoder, Iterable buffers) { + public static void decode(IDecodeContext decoder, Iterable buffers, UnionRegister register) { Iterator it = buffers.iterator(); - decoder.decode(nextNonEmptyBuffer(it)); + decoder.decode(nextNonEmptyBuffer(it), register); while (!decoder.isReady()) { - decoder.continueDecode(nextNonEmptyBuffer(it)); + decoder.continueDecode(nextNonEmptyBuffer(it), register); } } diff --git a/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java b/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java index 7d4ff017..b16e836f 100644 --- a/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java +++ b/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java @@ -16,14 +16,12 @@ package com.exactpro.epfast.decoder.ascii; -import com.exactpro.epfast.decoder.OverflowException; -import com.exactpro.epfast.decoder.message.DecoderState; +import com.exactpro.epfast.decoder.message.UnionRegister; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; -import java.io.IOException; import java.security.InvalidParameterException; import java.util.Collection; @@ -33,6 +31,8 @@ class TestDecodeAsciiString { + private UnionRegister register = new UnionRegister(); + static String fastAsciiStringOf(char character, int length) { if (character > 0 && character < 128) { StringBuilder stringBuilder = new StringBuilder(length); @@ -51,69 +51,69 @@ class TestNullable { private DecodeNullableAsciiString decoder = new DecodeNullableAsciiString(); @WithByteBuf("80") - void testNull(Collection buffers) throws IOException { - decode(decoder, buffers); + void testNull(Collection buffers) { + decode(decoder, buffers, register); assertTrue(decoder.isReady()); - assertNull(decoder.getValue()); + assertNull(register.stringValue); assertFalse(decoder.isOverlong()); } @WithByteBuf("00 80") - void testOptionalEmptyString(Collection buffers) throws IOException { - decode(decoder, buffers); + void testOptionalEmptyString(Collection buffers) { + decode(decoder, buffers, register); assertTrue(decoder.isReady()); - assertEquals("", decoder.getValue()); + assertEquals("", register.stringValue); assertFalse(decoder.isOverlong()); } @WithByteBuf("41 42 c3") - void testSimpleString(Collection buffers) throws IOException { - decode(decoder, buffers); + void testSimpleString(Collection buffers) { + decode(decoder, buffers, register); assertTrue(decoder.isReady()); - assertEquals("ABC", decoder.getValue()); + assertEquals("ABC", register.stringValue); assertFalse(decoder.isOverlong()); } @WithByteBuf("00 00 80") - void testZeroByteStringNullable1(Collection buffers) throws IOException { - decode(decoder, buffers); + void testZeroByteStringNullable1(Collection buffers) { + decode(decoder, buffers, register); assertTrue(decoder.isReady()); - assertEquals("\0", decoder.getValue()); + assertEquals("\0", register.stringValue); assertFalse(decoder.isOverlong()); } @WithByteBuf("00 00 00 00 80") - void testZeroByteStringNullable2(Collection buffers) throws IOException { - decode(decoder, buffers); + void testZeroByteStringNullable2(Collection buffers) { + decode(decoder, buffers, register); assertTrue(decoder.isReady()); - assertEquals("\0\0\0", decoder.getValue()); + assertEquals("\0\0\0", register.stringValue); assertFalse(decoder.isOverlong()); } @WithByteBuf("41 42 c3 42 42 c3 41 44 c3") - void testNullableReuse(Collection buffers) throws IOException { - decode(decoder, buffers); + void testNullableReuse(Collection buffers) { + decode(decoder, buffers, register); assertTrue(decoder.isReady()); assertFalse(decoder.isOverlong()); - assertEquals("ABC", decoder.getValue()); - decode(decoder, buffers); - assertEquals("BBC", decoder.getValue()); - decode(decoder, buffers); - assertEquals("ADC", decoder.getValue()); + assertEquals("ABC", register.stringValue); + decode(decoder, buffers, register); + assertEquals("BBC", register.stringValue); + decode(decoder, buffers, register); + assertEquals("ADC", register.stringValue); } @WithByteBuf("41 42 c3") - void testSimpleStringGetValueTwice(Collection buffers) throws IOException { - decode(decoder, buffers); + void testSimpleStringGetValueTwice(Collection buffers) { + decode(decoder, buffers, register); assertTrue(decoder.isReady()); assertFalse(decoder.isOverlong()); - assertEquals("ABC", decoder.getValue()); - assertEquals("ABC", decoder.getValue()); + assertEquals("ABC", register.stringValue); + assertEquals("ABC", register.stringValue); } @WithByteBuf("00 00 00 81") void testNullableOverlongNoException(Collection buffers) { - decode(decoder, buffers); + decode(decoder, buffers, register); assertTrue(decoder.isReady()); assertTrue(decoder.isOverlong()); } @@ -125,31 +125,31 @@ class TestOverflowException { @WithByteBuf("00 00 00 81") void testNullableOverlong1(Collection buffers) { - decode(decoder, buffers); + decode(decoder, buffers, register); assertTrue(decoder.isReady()); assertTrue(decoder.isOverlong()); - assertThrows(OverflowException.class, () -> decoder.getValue()); + assertTrue(register.isOverflow); } @Test void testNullableOverlong2() { - decoder.decode(fromHex(fastAsciiStringOf(')', 2 * DecodeAsciiString.MAX_ALLOWED_LENGTH))); + decoder.decode(fromHex(fastAsciiStringOf(')', 2 * DecodeAsciiString.MAX_ALLOWED_LENGTH)), register); assertTrue(decoder.isReady()); - assertThrows(OverflowException.class, () -> decoder.getValue()); + assertTrue(register.isOverflow); } } @WithByteBuf("00 00 80 00 00 00 00 80") - void testZeroByteStringNullableTwoValuesInRow(Collection buffers) throws IOException { - decode(decoder, buffers); + void testZeroByteStringNullableTwoValuesInRow(Collection buffers) { + decode(decoder, buffers, register); assertTrue(decoder.isReady()); assertFalse(decoder.isOverlong()); - assertEquals("\0", decoder.getValue()); + assertEquals("\0", register.stringValue); - decode(decoder, buffers); + decode(decoder, buffers, register); assertTrue(decoder.isReady()); assertFalse(decoder.isOverlong()); - assertEquals("\0\0\0", decoder.getValue()); + assertEquals("\0\0\0", register.stringValue); } } @@ -159,41 +159,41 @@ class TestMandatory { private DecodeMandatoryAsciiString decoder = new DecodeMandatoryAsciiString(); @WithByteBuf("80") - void testMandatoryEmptyString(Collection buffers) throws IOException { - decode(decoder, buffers); + void testMandatoryEmptyString(Collection buffers) { + decode(decoder, buffers, register); assertTrue(decoder.isReady()); assertFalse(decoder.isOverlong()); - assertEquals("", decoder.getValue()); + assertEquals("", register.stringValue); } @WithByteBuf("00 00 80") - void testZeroByteStringMandatory1(Collection buffers) throws IOException { - decode(decoder, buffers); + void testZeroByteStringMandatory1(Collection buffers) { + decode(decoder, buffers, register); assertTrue(decoder.isReady()); assertFalse(decoder.isOverlong()); - assertEquals("\0\0", decoder.getValue()); + assertEquals("\0\0", register.stringValue); } @WithByteBuf("00 00 00 00 80") - void testZeroByteStringMandatory2(Collection buffers) throws IOException { - decode(decoder, buffers); + void testZeroByteStringMandatory2(Collection buffers) { + decode(decoder, buffers, register); assertTrue(decoder.isReady()); assertFalse(decoder.isOverlong()); - assertEquals("\0\0\0\0", decoder.getValue()); + assertEquals("\0\0\0\0", register.stringValue); } @WithByteBuf("80") - void testMandatoryEmptyStringGetValueTwice(Collection buffers) throws IOException { - decode(decoder, buffers); + void testMandatoryEmptyStringGetValueTwice(Collection buffers) { + decode(decoder, buffers, register); assertTrue(decoder.isReady()); assertFalse(decoder.isOverlong()); - assertEquals("", decoder.getValue()); - assertEquals("", decoder.getValue()); + assertEquals("", register.stringValue); + assertEquals("", register.stringValue); } @WithByteBuf("00 00 00 81") void testMandatoryOverlongNoException(Collection buffers) { - decode(decoder, buffers); + decode(decoder, buffers, register); assertTrue(decoder.isReady()); assertTrue(decoder.isOverlong()); } @@ -205,31 +205,31 @@ class TestOverflowException { @WithByteBuf("00 81") void testMandatoryOverlong1(Collection buffers) { - decode(decoder, buffers); + decode(decoder, buffers, register); assertTrue(decoder.isReady()); assertTrue(decoder.isOverlong()); - assertThrows(OverflowException.class, () -> decoder.getValue()); + assertTrue(register.isOverflow); } @Test void testMandatoryOverlong2() { - decoder.decode(fromHex(fastAsciiStringOf('*', 3 * DecodeAsciiString.MAX_ALLOWED_LENGTH))); + decoder.decode(fromHex(fastAsciiStringOf('*', 3 * DecodeAsciiString.MAX_ALLOWED_LENGTH)), register); assertTrue(decoder.isReady()); - assertThrows(OverflowException.class, () -> decoder.getValue()); + assertTrue(register.isOverflow); } } @WithByteBuf("00 00 80 00 00 00 00 80") - void testZeroByteStringMandatoryTwoValuesInRow(Collection buffers) throws IOException { - decode(decoder, buffers); + void testZeroByteStringMandatoryTwoValuesInRow(Collection buffers) { + decode(decoder, buffers, register); assertTrue(decoder.isReady()); assertFalse(decoder.isOverlong()); - assertEquals("\0\0", decoder.getValue()); + assertEquals("\0\0", register.stringValue); - decode(decoder, buffers); + decode(decoder, buffers, register); assertTrue(decoder.isReady()); assertFalse(decoder.isOverlong()); - assertEquals("\0\0\0\0", decoder.getValue()); + assertEquals("\0\0\0\0", register.stringValue); } } } diff --git a/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java b/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java index b078fd88..3d7a6ec9 100644 --- a/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java +++ b/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java @@ -16,10 +16,10 @@ package com.exactpro.epfast.decoder.decimal; -import java.io.IOException; import java.math.BigDecimal; import java.util.Collection; +import com.exactpro.epfast.decoder.message.UnionRegister; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; @@ -32,247 +32,249 @@ class TestDecodeDecimal { private DecodeMandatoryDecimal mandatoryDecimalDecoder = new DecodeMandatoryDecimal(); + private UnionRegister register = new UnionRegister(); + @WithByteBuf("80") - void testNull(Collection buffers) throws IOException { - decode(nullableDecimalDecoder, buffers); + void testNull(Collection buffers) { + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); assertFalse(nullableDecimalDecoder.isOverlong()); - assertNull(nullableDecimalDecoder.getValue()); + assertNull(register.decimalValue); } @WithByteBuf("83 39 45 a3") - void testNullablePositive1(Collection buffers) throws IOException { - decode(nullableDecimalDecoder, buffers); + void testNullablePositive1(Collection buffers) { + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); assertFalse(nullableDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("94275500"), nullableDecimalDecoder.getValue()); + assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("82 04 3f 34 de") - void testNullablePositive(Collection buffers) throws IOException { - decode(nullableDecimalDecoder, buffers); + void testNullablePositive(Collection buffers) { + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); assertFalse(nullableDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("94275500"), nullableDecimalDecoder.getValue()); + assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("82 39 45 a3") - void testMandatoryPositive(Collection buffers) throws IOException { - decode(mandatoryDecimalDecoder, buffers); + void testMandatoryPositive(Collection buffers) { + decode(mandatoryDecimalDecoder, buffers, register); assertTrue(mandatoryDecimalDecoder.isReady()); assertFalse(mandatoryDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("94275500"), mandatoryDecimalDecoder.getValue()); + assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("81 04 3f 34 de") - void testMandatoryPositive2(Collection buffers) throws IOException { - decode(mandatoryDecimalDecoder, buffers); + void testMandatoryPositive2(Collection buffers) { + decode(mandatoryDecimalDecoder, buffers, register); assertTrue(mandatoryDecimalDecoder.isReady()); assertFalse(mandatoryDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("94275500"), mandatoryDecimalDecoder.getValue()); + assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("fe 39 45 a3") - void testMandatoryPositive3(Collection buffers) throws IOException { - decode(mandatoryDecimalDecoder, buffers); + void testMandatoryPositive3(Collection buffers) { + decode(mandatoryDecimalDecoder, buffers, register); assertTrue(mandatoryDecimalDecoder.isReady()); assertFalse(mandatoryDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("9427.55"), mandatoryDecimalDecoder.getValue()); + assertEquals(new BigDecimal("9427.55"), register.decimalValue); } @WithByteBuf("fe 39 45 a3") - void testNullablePositive3(Collection buffers) throws IOException { - decode(nullableDecimalDecoder, buffers); + void testNullablePositive3(Collection buffers) { + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); assertFalse(nullableDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("9427.55"), nullableDecimalDecoder.getValue()); + assertEquals(new BigDecimal("9427.55"), register.decimalValue); } @WithByteBuf("fe 46 3a dd") - void testNullableNegative(Collection buffers) throws IOException { - decode(nullableDecimalDecoder, buffers); + void testNullableNegative(Collection buffers) { + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); assertFalse(nullableDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("-9427.55"), nullableDecimalDecoder.getValue()); + assertEquals(new BigDecimal("-9427.55"), register.decimalValue); } @WithByteBuf("fd 7f 3f ff") - void testNullableNegativeSignExtension(Collection buffers) throws IOException { - decode(nullableDecimalDecoder, buffers); + void testNullableNegativeSignExtension(Collection buffers) { + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); assertFalse(nullableDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("-8.193"), nullableDecimalDecoder.getValue()); + assertEquals(new BigDecimal("-8.193"), register.decimalValue); } @WithByteBuf("39 45 a4 7f 3f ff") void testExponentIOException(Collection buffers) { - decode(nullableDecimalDecoder, buffers); + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); assertFalse(nullableDecimalDecoder.isOverlong()); - assertThrows(IOException.class, () -> nullableDecimalDecoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("82 04 3f 34 de") - void testNullablePositiveGetValueTwice(Collection buffers) throws IOException { - decode(nullableDecimalDecoder, buffers); + void testNullablePositiveGetValueTwice(Collection buffers) { + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); assertFalse(nullableDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("94275500"), nullableDecimalDecoder.getValue()); - assertEquals(new BigDecimal("94275500"), nullableDecimalDecoder.getValue()); + assertEquals(new BigDecimal("94275500"), register.decimalValue); + assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("82 39 45 a3") - void testMandatoryPositiveGetValueTwice(Collection buffers) throws IOException { - decode(mandatoryDecimalDecoder, buffers); + void testMandatoryPositiveGetValueTwice(Collection buffers) { + decode(mandatoryDecimalDecoder, buffers, register); assertTrue(mandatoryDecimalDecoder.isReady()); assertFalse(mandatoryDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("94275500"), mandatoryDecimalDecoder.getValue()); - assertEquals(new BigDecimal("94275500"), mandatoryDecimalDecoder.getValue()); + assertEquals(new BigDecimal("94275500"), register.decimalValue); + assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("83 39 45 a3 82 04 3f 34 de") - void testNullablePositiveTwoValuesInRow(Collection buffers) throws IOException { - decode(nullableDecimalDecoder, buffers); + void testNullablePositiveTwoValuesInRow(Collection buffers) { + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); assertFalse(nullableDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("94275500"), nullableDecimalDecoder.getValue()); + assertEquals(new BigDecimal("94275500"), register.decimalValue); - decode(nullableDecimalDecoder, buffers); + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); assertFalse(nullableDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("94275500"), nullableDecimalDecoder.getValue()); + assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("82 39 45 a3 81 04 3f 34 de") - void testMandatoryPositiveTwoValuesInRow(Collection buffers) throws IOException { - decode(mandatoryDecimalDecoder, buffers); + void testMandatoryPositiveTwoValuesInRow(Collection buffers) { + decode(mandatoryDecimalDecoder, buffers, register); assertTrue(mandatoryDecimalDecoder.isReady()); assertFalse(mandatoryDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("94275500"), mandatoryDecimalDecoder.getValue()); + assertEquals(new BigDecimal("94275500"), register.decimalValue); - decode(mandatoryDecimalDecoder, buffers); + decode(mandatoryDecimalDecoder, buffers, register); assertTrue(mandatoryDecimalDecoder.isReady()); assertFalse(mandatoryDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("94275500"), mandatoryDecimalDecoder.getValue()); + assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("08 00 00 00 81 39 45 a3") void testNullableExponentOverflow1(Collection buffers) { - decode(nullableDecimalDecoder, buffers); + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); - assertThrows(IOException.class, () -> nullableDecimalDecoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("08 00 00 00 80 39 45 a3") void testMandatoryExponentOverflow1(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers); + decode(mandatoryDecimalDecoder, buffers, register); assertTrue(mandatoryDecimalDecoder.isReady()); - assertThrows(IOException.class, () -> mandatoryDecimalDecoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("08 00 00 00 00 81 39 45 a3") void testNullableExponentOverflow2(Collection buffers) { - decode(nullableDecimalDecoder, buffers); + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); - assertThrows(IOException.class, () -> nullableDecimalDecoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("07 7f 00 7f 7f 7f ff 39 45 a3") void testMandatoryExponentOverflow2(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers); + decode(mandatoryDecimalDecoder, buffers, register); assertTrue(mandatoryDecimalDecoder.isReady()); - assertThrows(IOException.class, () -> mandatoryDecimalDecoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("86 01 00 00 00 00 00 00 00 00 80") void testNullableMantissaOverflow1(Collection buffers) { - decode(nullableDecimalDecoder, buffers); + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); - assertThrows(IOException.class, () -> nullableDecimalDecoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("86 01 00 00 00 00 00 00 00 00 80") void testMandatoryMantissaOverflow1(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers); + decode(mandatoryDecimalDecoder, buffers, register); assertTrue(mandatoryDecimalDecoder.isReady()); - assertThrows(IOException.class, () -> mandatoryDecimalDecoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("86 00 7f 00 7f 7f 7f 7f 7f 7f 7f ff") void testNullableMantissaOverflow2(Collection buffers) { - decode(nullableDecimalDecoder, buffers); + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); - assertThrows(IOException.class, () -> nullableDecimalDecoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("86 00 7f 00 7f 7f 7f 7f 7f 7f 7f ff") void testMandatoryMantissaOverflow2(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers); + decode(mandatoryDecimalDecoder, buffers, register); assertTrue(mandatoryDecimalDecoder.isReady()); - assertThrows(IOException.class, () -> mandatoryDecimalDecoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("00 83 39 45 a3") - void testNullableExponentOverlong(Collection buffers) throws IOException { - decode(nullableDecimalDecoder, buffers); + void testNullableExponentOverlong(Collection buffers) { + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); assertTrue(nullableDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("94275500"), nullableDecimalDecoder.getValue()); + assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("7f fe 46 3a dd") - void testNullableNegativeExponentOverlong(Collection buffers) throws IOException { - decode(nullableDecimalDecoder, buffers); + void testNullableNegativeExponentOverlong(Collection buffers) { + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); assertTrue(nullableDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("-9427.55"), nullableDecimalDecoder.getValue()); + assertEquals(new BigDecimal("-9427.55"), register.decimalValue); } @WithByteBuf("00 82 39 45 a3") - void testMandatoryExponentOverlong(Collection buffers) throws IOException { - decode(mandatoryDecimalDecoder, buffers); + void testMandatoryExponentOverlong(Collection buffers) { + decode(mandatoryDecimalDecoder, buffers, register); assertTrue(mandatoryDecimalDecoder.isReady()); assertTrue(mandatoryDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("94275500"), mandatoryDecimalDecoder.getValue()); + assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("7f fe 46 3a dd") - void testMandatoryNegativeExponentOverlong(Collection buffers) throws IOException { - decode(mandatoryDecimalDecoder, buffers); + void testMandatoryNegativeExponentOverlong(Collection buffers) { + decode(mandatoryDecimalDecoder, buffers, register); assertTrue(mandatoryDecimalDecoder.isReady()); assertTrue(mandatoryDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("-9427.55"), mandatoryDecimalDecoder.getValue()); + assertEquals(new BigDecimal("-9427.55"), register.decimalValue); } @WithByteBuf("fe 7f 46 3a dd") - void testNullableNegativeMantissaOverlong(Collection buffers) throws IOException { - decode(nullableDecimalDecoder, buffers); + void testNullableNegativeMantissaOverlong(Collection buffers) { + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); assertTrue(nullableDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("-9427.55"), nullableDecimalDecoder.getValue()); + assertEquals(new BigDecimal("-9427.55"), register.decimalValue); } @WithByteBuf("83 00 39 45 a3") - void testNullableMantissaOverlong(Collection buffers) throws IOException { - decode(nullableDecimalDecoder, buffers); + void testNullableMantissaOverlong(Collection buffers) { + decode(nullableDecimalDecoder, buffers, register); assertTrue(nullableDecimalDecoder.isReady()); assertTrue(nullableDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("94275500"), nullableDecimalDecoder.getValue()); + assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("82 00 39 45 a3") - void testMandatoryMantissaOverlong(Collection buffers) throws IOException { - decode(mandatoryDecimalDecoder, buffers); + void testMandatoryMantissaOverlong(Collection buffers) { + decode(mandatoryDecimalDecoder, buffers, register); assertTrue(mandatoryDecimalDecoder.isReady()); assertTrue(mandatoryDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("94275500"), mandatoryDecimalDecoder.getValue()); + assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("fe 7f 46 3a dd") - void testMandatoryNegativeMantissaOverlong(Collection buffers) throws IOException { - decode(mandatoryDecimalDecoder, buffers); + void testMandatoryNegativeMantissaOverlong(Collection buffers) { + decode(mandatoryDecimalDecoder, buffers, register); assertTrue(mandatoryDecimalDecoder.isReady()); assertTrue(mandatoryDecimalDecoder.isOverlong()); - assertEquals(new BigDecimal("-9427.55"), mandatoryDecimalDecoder.getValue()); + assertEquals(new BigDecimal("-9427.55"), register.decimalValue); } } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java index 14d40d20..61f933aa 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java @@ -16,11 +16,11 @@ package com.exactpro.epfast.decoder.integer; +import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; import com.exactpro.junit5.WithByteBuf; -import java.io.IOException; import java.util.Collection; import static org.junit.jupiter.api.Assertions.*; @@ -32,287 +32,289 @@ class TestInt32 { private DecodeMandatoryInt32 mandatoryInt32Decoder = new DecodeMandatoryInt32(); + private UnionRegister register = new UnionRegister(); + @WithByteBuf("80") - void testNull(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void testNull(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertNull(nullableInt32Decoder.getValue()); + assertTrue(register.isNull); } @WithByteBuf("81") - void optionalZero(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void optionalZero(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertEquals(0, nullableInt32Decoder.getValue()); + assertEquals(0, register.int32Value); } @WithByteBuf("80") - void mandatoryZero(Collection buffers) throws IOException { - decode(mandatoryInt32Decoder, buffers); + void mandatoryZero(Collection buffers) { + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertEquals(0, mandatoryInt32Decoder.getValue()); + assertEquals(0, register.int32Value); } @WithByteBuf("08 00 00 00 80") - void testMaxNullable(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void testMaxNullable(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertEquals(Integer.MAX_VALUE, nullableInt32Decoder.getValue()); + assertEquals(Integer.MAX_VALUE, register.int32Value); } @WithByteBuf("07 7f 7f 7f ff") - void testMaxMandatory(Collection buffers) throws IOException { - decode(mandatoryInt32Decoder, buffers); + void testMaxMandatory(Collection buffers) { + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertEquals(Integer.MAX_VALUE, mandatoryInt32Decoder.getValue()); + assertEquals(Integer.MAX_VALUE, register.int32Value); } @WithByteBuf("78 00 00 00 80") - void testMinNullable(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void testMinNullable(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertEquals(Integer.MIN_VALUE, nullableInt32Decoder.getValue()); + assertEquals(Integer.MIN_VALUE, register.int32Value); } @WithByteBuf("78 00 00 00 80") - void testMinMandatory(Collection buffers) throws IOException { - decode(mandatoryInt32Decoder, buffers); + void testMinMandatory(Collection buffers) { + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertEquals(Integer.MIN_VALUE, mandatoryInt32Decoder.getValue()); + assertEquals(Integer.MIN_VALUE, register.int32Value); } @WithByteBuf("08 00 00 00 81") void testMaxOverflowNullable1(Collection buffers) { - decode(nullableInt32Decoder, buffers); + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertThrows(IOException.class, () -> nullableInt32Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("08 00 00 00 00 00 00 80") void testMaxOverflowNullable2(Collection buffers) { - decode(nullableInt32Decoder, buffers); + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertThrows(IOException.class, () -> nullableInt32Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("08 00 00 00 80") void testMaxOverflowMandatory1(Collection buffers) { - decode(mandatoryInt32Decoder, buffers); + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertThrows(IOException.class, () -> mandatoryInt32Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("07 7f 00 7f 7f 7f ff") void testMaxOverflowMandatory2(Collection buffers) { - decode(mandatoryInt32Decoder, buffers); + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertThrows(IOException.class, () -> mandatoryInt32Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("77 7f 7f 7f ff") void testMinOverflowNullable1(Collection buffers) { - decode(nullableInt32Decoder, buffers); + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertThrows(IOException.class, () -> nullableInt32Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("78 00 00 00 00 80") void testMinOverflowNullable2(Collection buffers) { - decode(nullableInt32Decoder, buffers); + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertThrows(IOException.class, () -> nullableInt32Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("77 7f 7f 7f ff") void testMinOverflowMandatory1(Collection buffers) { - decode(mandatoryInt32Decoder, buffers); + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertThrows(IOException.class, () -> mandatoryInt32Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("78 00 00 00 00 80") void testMinOverflowMandatory2(Collection buffers) { - decode(mandatoryInt32Decoder, buffers); + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertThrows(IOException.class, () -> mandatoryInt32Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("39 45 a4") - void optionalPositive(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void optionalPositive(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertEquals(942755, nullableInt32Decoder.getValue()); + assertEquals(942755, register.int32Value); } @WithByteBuf("39 45 a3") - void mandatoryPositive(Collection buffers) throws IOException { - decode(mandatoryInt32Decoder, buffers); + void mandatoryPositive(Collection buffers) { + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertEquals(942755, mandatoryInt32Decoder.getValue()); + assertEquals(942755, register.int32Value); } @WithByteBuf("46 3a dd") - void optionalNegative(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void optionalNegative(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertEquals(-942755, nullableInt32Decoder.getValue()); + assertEquals(-942755, register.int32Value); } @WithByteBuf("7c 1b 1b 9d") - void mandatoryNegative(Collection buffers) throws IOException { - decode(mandatoryInt32Decoder, buffers); + void mandatoryNegative(Collection buffers) { + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertEquals(-7942755, mandatoryInt32Decoder.getValue()); + assertEquals(-7942755, register.int32Value); } @WithByteBuf("ff") - void optionalMinusOne(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void optionalMinusOne(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertEquals(-1, nullableInt32Decoder.getValue()); + assertEquals(-1, register.int32Value); } @WithByteBuf("ff") - void mandatoryMinusOne(Collection buffers) throws IOException { - decode(mandatoryInt32Decoder, buffers); + void mandatoryMinusOne(Collection buffers) { + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertEquals(-1, mandatoryInt32Decoder.getValue()); + assertEquals(-1, register.int32Value); } @WithByteBuf("00 00 40 82") - void optionalSignExtensionPositive(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void optionalSignExtensionPositive(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertEquals(8193, nullableInt32Decoder.getValue()); + assertEquals(8193, register.int32Value); } @WithByteBuf("00 00 40 81") - void mandatorySignExtensionPositive(Collection buffers) throws IOException { - decode(mandatoryInt32Decoder, buffers); + void mandatorySignExtensionPositive(Collection buffers) { + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertEquals(8193, mandatoryInt32Decoder.getValue()); + assertEquals(8193, register.int32Value); } @WithByteBuf("7f 3f ff") - void optionalSignExtensionNegative(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void optionalSignExtensionNegative(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertEquals(-8193, nullableInt32Decoder.getValue()); + assertEquals(-8193, register.int32Value); } @WithByteBuf("7f 3f ff") - void mandatorySignExtensionNegative(Collection buffers) throws IOException { - decode(mandatoryInt32Decoder, buffers); + void mandatorySignExtensionNegative(Collection buffers) { + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertEquals(-8193, mandatoryInt32Decoder.getValue()); + assertEquals(-8193, register.int32Value); } @WithByteBuf("7f 3f ff 7f 3f ff") - void mandatoryNegativeTwoValuesInRow(Collection buffers) throws IOException { - decode(mandatoryInt32Decoder, buffers); + void mandatoryNegativeTwoValuesInRow(Collection buffers) { + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertEquals(-8193, mandatoryInt32Decoder.getValue()); + assertEquals(-8193, register.int32Value); - decode(mandatoryInt32Decoder, buffers); + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertEquals(-8193, mandatoryInt32Decoder.getValue()); + assertEquals(-8193, register.int32Value); } @WithByteBuf("00 00 40 81 00 00 40 81") - void mandatoryPositiveTwoValuesInRow(Collection buffers) throws IOException { - decode(mandatoryInt32Decoder, buffers); + void mandatoryPositiveTwoValuesInRow(Collection buffers) { + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertEquals(8193, mandatoryInt32Decoder.getValue()); + assertEquals(8193, register.int32Value); - decode(mandatoryInt32Decoder, buffers); + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertEquals(8193, mandatoryInt32Decoder.getValue()); + assertEquals(8193, register.int32Value); } @WithByteBuf("7f 3f ff 7f 3f ff") - void optionalNegativeTwoValuesInRow(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void optionalNegativeTwoValuesInRow(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertEquals(-8193, nullableInt32Decoder.getValue()); + assertEquals(-8193, register.int32Value); - decode(nullableInt32Decoder, buffers); + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertEquals(-8193, nullableInt32Decoder.getValue()); + assertEquals(-8193, register.int32Value); } @WithByteBuf("00 00 40 82 00 00 40 82") - void optionalPositiveTwoValuesInRow(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void optionalPositiveTwoValuesInRow(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertEquals(8193, nullableInt32Decoder.getValue()); + assertEquals(8193, register.int32Value); - decode(nullableInt32Decoder, buffers); + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertEquals(8193, nullableInt32Decoder.getValue()); + assertEquals(8193, register.int32Value); } @WithByteBuf("00 39 45 a4") - void mandatoryOverlong(Collection buffers) throws IOException { - decode(mandatoryInt32Decoder, buffers); + void mandatoryOverlong(Collection buffers) { + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); assertTrue(mandatoryInt32Decoder.isOverlong()); - assertEquals(942756, mandatoryInt32Decoder.getValue()); + assertEquals(942756, register.int32Value); } @WithByteBuf("00 40 81") - void mandatoryNotOverlong(Collection buffers) throws IOException { - decode(mandatoryInt32Decoder, buffers); + void mandatoryNotOverlong(Collection buffers) { + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); assertFalse(mandatoryInt32Decoder.isOverlong()); - assertEquals(8193, mandatoryInt32Decoder.getValue()); + assertEquals(8193, register.int32Value); } @WithByteBuf("7f 7c 1b 1b 9d") - void mandatoryOverlongNegative(Collection buffers) throws IOException { - decode(mandatoryInt32Decoder, buffers); + void mandatoryOverlongNegative(Collection buffers) { + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); assertTrue(mandatoryInt32Decoder.isOverlong()); - assertEquals(-7942755, mandatoryInt32Decoder.getValue()); + assertEquals(-7942755, register.int32Value); } @WithByteBuf("7f 3f ff") - void mandatoryNotOverlongNegative(Collection buffers) throws IOException { - decode(mandatoryInt32Decoder, buffers); + void mandatoryNotOverlongNegative(Collection buffers) { + decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); assertFalse(mandatoryInt32Decoder.isOverlong()); - assertEquals(-8193, mandatoryInt32Decoder.getValue()); + assertEquals(-8193, register.int32Value); } @WithByteBuf("00 39 45 a4") - void nullableOverlong(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void nullableOverlong(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); assertTrue(nullableInt32Decoder.isOverlong()); - assertEquals(942755, nullableInt32Decoder.getValue()); + assertEquals(942755, register.int32Value); } @WithByteBuf("00 40 81") - void nullableNotOverlong(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void nullableNotOverlong(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); assertFalse(nullableInt32Decoder.isOverlong()); - assertEquals(8192, nullableInt32Decoder.getValue()); + assertEquals(8192, register.int32Value); } @WithByteBuf("7f 7c 1b 1b 9d") - void nullableOverlongNegative(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void nullableOverlongNegative(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); assertTrue(nullableInt32Decoder.isOverlong()); - assertEquals(-7942755, nullableInt32Decoder.getValue()); + assertEquals(-7942755, register.int32Value); } @WithByteBuf("7f 3f ff") - void nullableNotOverlongNegative(Collection buffers) throws IOException { - decode(nullableInt32Decoder, buffers); + void nullableNotOverlongNegative(Collection buffers) { + decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); assertFalse(nullableInt32Decoder.isOverlong()); - assertEquals(-8193, nullableInt32Decoder.getValue()); + assertEquals(-8193, register.int32Value); } } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java index 40563632..caa275c9 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java @@ -16,10 +16,10 @@ package com.exactpro.epfast.decoder.integer; +import com.exactpro.epfast.decoder.message.UnionRegister; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; -import java.io.IOException; import java.util.Collection; import static org.junit.jupiter.api.Assertions.*; @@ -31,286 +31,288 @@ class TestInt64 { private DecodeMandatoryInt64 mandatoryInt64Decoder = new DecodeMandatoryInt64(); + private UnionRegister register = new UnionRegister(); + @WithByteBuf("80") - void testNull(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void testNull(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertNull(nullableInt64Decoder.getValue()); + assertTrue(register.isNull); } @WithByteBuf("81") - void optionalZero(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void optionalZero(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertEquals(0, nullableInt64Decoder.getValue()); + assertEquals(0, register.int64Value); } @WithByteBuf("80") - void mandatoryZero(Collection buffers) throws IOException { - decode(mandatoryInt64Decoder, buffers); + void mandatoryZero(Collection buffers) { + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertEquals(0, mandatoryInt64Decoder.getValue()); + assertEquals(0, register.int64Value); } @WithByteBuf("01 00 00 00 00 00 00 00 00 80") - void testMaxNullable(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void testMaxNullable(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertEquals(Long.MAX_VALUE, nullableInt64Decoder.getValue()); + assertEquals(Long.MAX_VALUE, register.int64Value); } @WithByteBuf("00 7f 7f 7f 7f 7f 7f 7f 7f ff") - void testMaxMandatory(Collection buffers) throws IOException { - decode(mandatoryInt64Decoder, buffers); + void testMaxMandatory(Collection buffers) { + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertEquals(Long.MAX_VALUE, mandatoryInt64Decoder.getValue()); + assertEquals(Long.MAX_VALUE, register.int64Value); } @WithByteBuf("7f 00 00 00 00 00 00 00 00 80") - void testMinNullable(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void testMinNullable(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertEquals(Long.MIN_VALUE, nullableInt64Decoder.getValue()); + assertEquals(Long.MIN_VALUE, register.int64Value); } @WithByteBuf("7f 00 00 00 00 00 00 00 00 80") - void testMinMandatory(Collection buffers) throws IOException { - decode(mandatoryInt64Decoder, buffers); + void testMinMandatory(Collection buffers) { + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertEquals(Long.MIN_VALUE, mandatoryInt64Decoder.getValue()); + assertEquals(Long.MIN_VALUE, register.int64Value); } @WithByteBuf("01 00 00 00 00 00 00 00 00 81") void testMaxOverflowNullable1(Collection buffers) { - decode(nullableInt64Decoder, buffers); + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertThrows(IOException.class, () -> nullableInt64Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("01 00 00 00 00 00 00 00 00 00 80") void testMaxOverflowNullable2(Collection buffers) { - decode(nullableInt64Decoder, buffers); + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertThrows(IOException.class, () -> nullableInt64Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("01 00 00 00 00 00 00 00 00 80") void testMaxOverflowMandatory1(Collection buffers) { - decode(mandatoryInt64Decoder, buffers); + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertThrows(IOException.class, () -> mandatoryInt64Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("00 7f 00 7f 7f 7f 7f 7f 7f 7f ff") void testMaxOverflowMandatory2(Collection buffers) { - decode(mandatoryInt64Decoder, buffers); + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertThrows(IOException.class, () -> mandatoryInt64Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("77 7f 7f 7f 7f 7f 7f 7f 7f ff") void testMinOverflowNullable1(Collection buffers) { - decode(nullableInt64Decoder, buffers); + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertThrows(IOException.class, () -> nullableInt64Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("7f 00 00 00 00 00 00 00 00 00 80") void testMinOverflowNullable2(Collection buffers) { - decode(nullableInt64Decoder, buffers); + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertThrows(IOException.class, () -> nullableInt64Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("77 7f 7f 7f 7f 7f 7f 7f 7f ff") void testMinOverflowMandatory1(Collection buffers) { - decode(mandatoryInt64Decoder, buffers); + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertThrows(IOException.class, () -> mandatoryInt64Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("7f 00 00 00 00 00 00 00 00 00 80") void testMinOverflowMandatory2(Collection buffers) { - decode(mandatoryInt64Decoder, buffers); + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertThrows(IOException.class, () -> mandatoryInt64Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("39 45 a4") - void optionalPositive(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void optionalPositive(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertEquals(942755, nullableInt64Decoder.getValue()); + assertEquals(942755, register.int64Value); } @WithByteBuf("39 45 a3") - void mandatoryPositive(Collection buffers) throws IOException { - decode(mandatoryInt64Decoder, buffers); + void mandatoryPositive(Collection buffers) { + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertEquals(942755, mandatoryInt64Decoder.getValue()); + assertEquals(942755, register.int64Value); } @WithByteBuf("46 3a dd") - void optionalNegative(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void optionalNegative(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertEquals(-942755, nullableInt64Decoder.getValue()); + assertEquals(-942755, register.int64Value); } @WithByteBuf("7c 1b 1b 9d") - void mandatoryNegative(Collection buffers) throws IOException { - decode(mandatoryInt64Decoder, buffers); + void mandatoryNegative(Collection buffers) { + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertEquals(-7942755, mandatoryInt64Decoder.getValue()); + assertEquals(-7942755, register.int64Value); } @WithByteBuf("ff") - void optionalMinusOne(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void optionalMinusOne(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertEquals(-1, nullableInt64Decoder.getValue()); + assertEquals(-1, register.int64Value); } @WithByteBuf("ff") - void mandatoryMinusOne(Collection buffers) throws IOException { - decode(mandatoryInt64Decoder, buffers); + void mandatoryMinusOne(Collection buffers) { + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertEquals(-1, mandatoryInt64Decoder.getValue()); + assertEquals(-1, register.int64Value); } @WithByteBuf("00 00 40 82") - void optionalSignExtensionPositive(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void optionalSignExtensionPositive(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertEquals(8193, nullableInt64Decoder.getValue()); + assertEquals(8193, register.int64Value); } @WithByteBuf("00 00 40 81") - void mandatorySignExtensionPositive(Collection buffers) throws IOException { - decode(mandatoryInt64Decoder, buffers); + void mandatorySignExtensionPositive(Collection buffers) { + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertEquals(8193, mandatoryInt64Decoder.getValue()); + assertEquals(8193, register.int64Value); } @WithByteBuf("7f 3f ff") - void optionalSignExtensionNegative(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void optionalSignExtensionNegative(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertEquals(-8193, nullableInt64Decoder.getValue()); + assertEquals(-8193, register.int64Value); } @WithByteBuf("7f 3f ff") - void mandatorySignExtensionNegative(Collection buffers) throws IOException { - decode(mandatoryInt64Decoder, buffers); + void mandatorySignExtensionNegative(Collection buffers) { + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertEquals(-8193, mandatoryInt64Decoder.getValue()); + assertEquals(-8193, register.int64Value); } @WithByteBuf("7f 3f ff 7f 3f ff") - void mandatoryNegativeTwoValuesInRow(Collection buffers) throws IOException { - decode(mandatoryInt64Decoder, buffers); + void mandatoryNegativeTwoValuesInRow(Collection buffers) { + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertEquals(-8193, mandatoryInt64Decoder.getValue()); + assertEquals(-8193, register.int64Value); - decode(mandatoryInt64Decoder, buffers); + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertEquals(-8193, mandatoryInt64Decoder.getValue()); + assertEquals(-8193, register.int64Value); } @WithByteBuf("00 00 40 81 00 00 40 81") - void mandatoryPositiveTwoValuesInRow(Collection buffers) throws IOException { - decode(mandatoryInt64Decoder, buffers); + void mandatoryPositiveTwoValuesInRow(Collection buffers) { + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertEquals(8193, mandatoryInt64Decoder.getValue()); + assertEquals(8193, register.int64Value); - decode(mandatoryInt64Decoder, buffers); + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertEquals(8193, mandatoryInt64Decoder.getValue()); + assertEquals(8193, register.int64Value); } @WithByteBuf("7f 3f ff 7f 3f ff") - void optionalNegativeTwoValuesInRow(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void optionalNegativeTwoValuesInRow(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertEquals(-8193, nullableInt64Decoder.getValue()); + assertEquals(-8193, register.int64Value); - decode(nullableInt64Decoder, buffers); + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertEquals(-8193, nullableInt64Decoder.getValue()); + assertEquals(-8193, register.int64Value); } @WithByteBuf("00 00 40 82 00 00 40 82") - void optionalPositiveTwoValuesInRow(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void optionalPositiveTwoValuesInRow(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertEquals(8193, nullableInt64Decoder.getValue()); + assertEquals(8193, register.int64Value); - decode(nullableInt64Decoder, buffers); + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); - assertEquals(8193, nullableInt64Decoder.getValue()); + assertEquals(8193, register.int64Value); } @WithByteBuf("00 39 45 a4") - void mandatoryOverlong(Collection buffers) throws IOException { - decode(mandatoryInt64Decoder, buffers); + void mandatoryOverlong(Collection buffers) { + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); assertTrue(mandatoryInt64Decoder.isOverlong()); - assertEquals(942756, mandatoryInt64Decoder.getValue()); + assertEquals(942756, register.int64Value); } @WithByteBuf("00 40 81") - void mandatoryNotOverlong(Collection buffers) throws IOException { - decode(mandatoryInt64Decoder, buffers); + void mandatoryNotOverlong(Collection buffers) { + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); assertFalse(mandatoryInt64Decoder.isOverlong()); - assertEquals(8193, mandatoryInt64Decoder.getValue()); + assertEquals(8193, register.int64Value); } @WithByteBuf("7f 7c 1b 1b 9d") - void mandatoryOverlongNegative(Collection buffers) throws IOException { - decode(mandatoryInt64Decoder, buffers); + void mandatoryOverlongNegative(Collection buffers) { + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); assertTrue(mandatoryInt64Decoder.isOverlong()); - assertEquals(-7942755, mandatoryInt64Decoder.getValue()); + assertEquals(-7942755, register.int64Value); } @WithByteBuf("7f 3f ff") - void mandatoryNotOverlongNegative(Collection buffers) throws IOException { - decode(mandatoryInt64Decoder, buffers); + void mandatoryNotOverlongNegative(Collection buffers) { + decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); assertFalse(mandatoryInt64Decoder.isOverlong()); - assertEquals(-8193, mandatoryInt64Decoder.getValue()); + assertEquals(-8193, register.int64Value); } @WithByteBuf("00 39 45 a4") - void nullableOverlong(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void nullableOverlong(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); assertTrue(nullableInt64Decoder.isOverlong()); - assertEquals(942755, nullableInt64Decoder.getValue()); + assertEquals(942755, register.int64Value); } @WithByteBuf("00 40 81") - void nullableNotOverlong(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void nullableNotOverlong(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); assertFalse(nullableInt64Decoder.isOverlong()); - assertEquals(8192, nullableInt64Decoder.getValue()); + assertEquals(8192, register.int64Value); } @WithByteBuf("7f 7c 1b 1b 9d") - void nullableOverlongNegative(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void nullableOverlongNegative(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); assertTrue(nullableInt64Decoder.isOverlong()); - assertEquals(-7942755, nullableInt64Decoder.getValue()); + assertEquals(-7942755, register.int64Value); } @WithByteBuf("7f 3f ff") - void nullableNotOverlongNegative(Collection buffers) throws IOException { - decode(nullableInt64Decoder, buffers); + void nullableNotOverlongNegative(Collection buffers) { + decode(nullableInt64Decoder, buffers, register); assertTrue(nullableInt64Decoder.isReady()); assertFalse(nullableInt64Decoder.isOverlong()); - assertEquals(-8193, nullableInt64Decoder.getValue()); + assertEquals(-8193, register.int64Value); } } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java index 1c11f83f..7e851086 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java @@ -16,10 +16,10 @@ package com.exactpro.epfast.decoder.integer; +import com.exactpro.epfast.decoder.message.UnionRegister; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; -import java.io.IOException; import java.util.Collection; import static org.junit.jupiter.api.Assertions.*; @@ -30,158 +30,160 @@ class TestUInt32 { private DecodeNullableUInt32 nullableUInt32Decoder = new DecodeNullableUInt32(); private DecodeMandatoryUInt32 mandatoryUInt32Decoder = new DecodeMandatoryUInt32(); + + private UnionRegister register = new UnionRegister(); @WithByteBuf("80") - void testNull(Collection buffers) throws IOException { - decode(nullableUInt32Decoder, buffers); + void testNull(Collection buffers) { + decode(nullableUInt32Decoder, buffers, register); assertTrue(nullableUInt32Decoder.isReady()); - assertNull(nullableUInt32Decoder.getValue()); + assertTrue(register.isNull); } @WithByteBuf("81") - void optionalZero(Collection buffers) throws IOException { - decode(nullableUInt32Decoder, buffers); + void optionalZero(Collection buffers) { + decode(nullableUInt32Decoder, buffers, register); assertTrue(nullableUInt32Decoder.isReady()); - assertEquals(0, nullableUInt32Decoder.getValue()); + assertEquals(0, register.uInt32Value); } @WithByteBuf("80") - void mandatoryZero(Collection buffers) throws IOException { - decode(mandatoryUInt32Decoder, buffers); + void mandatoryZero(Collection buffers) { + decode(mandatoryUInt32Decoder, buffers, register); assertTrue(mandatoryUInt32Decoder.isReady()); - assertEquals(0, mandatoryUInt32Decoder.getValue()); + assertEquals(0, register.uInt32Value); } @WithByteBuf("10 00 00 00 80") - void testMaxNullable(Collection buffers) throws IOException { - decode(nullableUInt32Decoder, buffers); + void testMaxNullable(Collection buffers) { + decode(nullableUInt32Decoder, buffers, register); assertTrue(nullableUInt32Decoder.isReady()); - assertEquals(4294967295L, nullableUInt32Decoder.getValue()); + assertEquals(4294967295L, register.uInt32Value); } @WithByteBuf("0f 7f 7f 7f ff") - void testMaxMandatory(Collection buffers) throws IOException { - decode(mandatoryUInt32Decoder, buffers); + void testMaxMandatory(Collection buffers) { + decode(mandatoryUInt32Decoder, buffers, register); assertTrue(mandatoryUInt32Decoder.isReady()); - assertEquals(4294967295L, mandatoryUInt32Decoder.getValue()); + assertEquals(4294967295L, register.uInt32Value); } @WithByteBuf("10 00 00 00 81") void testMaxOverflowNullable1(Collection buffers) { - decode(nullableUInt32Decoder, buffers); + decode(nullableUInt32Decoder, buffers, register); assertTrue(nullableUInt32Decoder.isReady()); - assertThrows(IOException.class, () -> nullableUInt32Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("10 00 00 00 00 00 80") void testMaxOverflowNullable2(Collection buffers) { - decode(nullableUInt32Decoder, buffers); + decode(nullableUInt32Decoder, buffers, register); assertTrue(nullableUInt32Decoder.isReady()); - assertThrows(IOException.class, () -> nullableUInt32Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("10 00 00 00 80") void testMaxOverflowMandatory1(Collection buffers) { - decode(mandatoryUInt32Decoder, buffers); + decode(mandatoryUInt32Decoder, buffers, register); assertTrue(mandatoryUInt32Decoder.isReady()); - assertThrows(IOException.class, () -> mandatoryUInt32Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("0f 7f 7f 7f 7f 00 ff") void testMaxOverflowMandatory2(Collection buffers) { - decode(mandatoryUInt32Decoder, buffers); + decode(mandatoryUInt32Decoder, buffers, register); assertTrue(mandatoryUInt32Decoder.isReady()); - assertThrows(IOException.class, () -> mandatoryUInt32Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("39 45 a4") - void optionalSimpleNumber(Collection buffers) throws IOException { - decode(nullableUInt32Decoder, buffers); + void optionalSimpleNumber(Collection buffers) { + decode(nullableUInt32Decoder, buffers, register); assertTrue(nullableUInt32Decoder.isReady()); - assertEquals(942755, nullableUInt32Decoder.getValue()); + assertEquals(942755, register.uInt32Value); } @WithByteBuf("0f 7f 7f 7f ff") - void optionalSimpleNumber2(Collection buffers) throws IOException { - decode(nullableUInt32Decoder, buffers); + void optionalSimpleNumber2(Collection buffers) { + decode(nullableUInt32Decoder, buffers, register); assertTrue(nullableUInt32Decoder.isReady()); - assertEquals(4294967294L, nullableUInt32Decoder.getValue()); + assertEquals(4294967294L, register.uInt32Value); } @WithByteBuf("39 45 a3") - void mandatorySimpleNumber(Collection buffers) throws IOException { - decode(mandatoryUInt32Decoder, buffers); + void mandatorySimpleNumber(Collection buffers) { + decode(mandatoryUInt32Decoder, buffers, register); assertTrue(mandatoryUInt32Decoder.isReady()); - assertEquals(942755, mandatoryUInt32Decoder.getValue()); + assertEquals(942755, register.uInt32Value); } @WithByteBuf("39 45 a4") - void optionalSimpleNumberGetValueTwice(Collection buffers) throws IOException { - decode(nullableUInt32Decoder, buffers); + void optionalSimpleNumberGetValueTwice(Collection buffers) { + decode(nullableUInt32Decoder, buffers, register); assertTrue(nullableUInt32Decoder.isReady()); - assertEquals(942755, nullableUInt32Decoder.getValue()); - assertEquals(942755, nullableUInt32Decoder.getValue()); + assertEquals(942755, register.uInt32Value); + assertEquals(942755, register.uInt32Value); } @WithByteBuf("39 45 a3") - void mandatorySimpleNumberGetValueTwice(Collection buffers) throws IOException { - decode(mandatoryUInt32Decoder, buffers); + void mandatorySimpleNumberGetValueTwice(Collection buffers) { + decode(mandatoryUInt32Decoder, buffers, register); assertTrue(mandatoryUInt32Decoder.isReady()); - assertEquals(942755, mandatoryUInt32Decoder.getValue()); - assertEquals(942755, mandatoryUInt32Decoder.getValue()); + assertEquals(942755, register.uInt32Value); + assertEquals(942755, register.uInt32Value); } @WithByteBuf("39 45 a4 0f 7f 7f 7f ff") - void optionalSimpleNumbersTwoValuesInRow(Collection buffers) throws IOException { - decode(nullableUInt32Decoder, buffers); + void optionalSimpleNumbersTwoValuesInRow(Collection buffers) { + decode(nullableUInt32Decoder, buffers, register); assertTrue(nullableUInt32Decoder.isReady()); - assertEquals(942755, nullableUInt32Decoder.getValue()); + assertEquals(942755, register.uInt32Value); - decode(nullableUInt32Decoder, buffers); + decode(nullableUInt32Decoder, buffers, register); assertTrue(nullableUInt32Decoder.isReady()); - assertEquals(4294967294L, nullableUInt32Decoder.getValue()); + assertEquals(4294967294L, register.uInt32Value); } @WithByteBuf("39 45 a3 39 45 a3") - void mandatorySimpleNumbersTwoValuesInRow(Collection buffers) throws IOException { - decode(mandatoryUInt32Decoder, buffers); + void mandatorySimpleNumbersTwoValuesInRow(Collection buffers) { + decode(mandatoryUInt32Decoder, buffers, register); assertTrue(mandatoryUInt32Decoder.isReady()); - assertEquals(942755, mandatoryUInt32Decoder.getValue()); + assertEquals(942755, register.uInt32Value); - decode(mandatoryUInt32Decoder, buffers); + decode(mandatoryUInt32Decoder, buffers, register); assertTrue(mandatoryUInt32Decoder.isReady()); - assertEquals(942755, mandatoryUInt32Decoder.getValue()); + assertEquals(942755, register.uInt32Value); } @WithByteBuf("00 39 45 a4") - void mandatoryOverlong(Collection buffers) throws IOException { - decode(mandatoryUInt32Decoder, buffers); + void mandatoryOverlong(Collection buffers) { + decode(mandatoryUInt32Decoder, buffers, register); assertTrue(mandatoryUInt32Decoder.isReady()); assertTrue(mandatoryUInt32Decoder.isOverlong()); - assertEquals(942756, mandatoryUInt32Decoder.getValue()); + assertEquals(942756, register.uInt32Value); } @WithByteBuf("00 40 81") - void mandatoryNotOverlong(Collection buffers) throws IOException { - decode(mandatoryUInt32Decoder, buffers); + void mandatoryNotOverlong(Collection buffers) { + decode(mandatoryUInt32Decoder, buffers, register); assertTrue(mandatoryUInt32Decoder.isReady()); assertFalse(mandatoryUInt32Decoder.isOverlong()); - assertEquals(8193, mandatoryUInt32Decoder.getValue()); + assertEquals(8193, register.uInt32Value); } @WithByteBuf("00 39 45 a4") - void nullableOverlong(Collection buffers) throws IOException { - decode(nullableUInt32Decoder, buffers); + void nullableOverlong(Collection buffers) { + decode(nullableUInt32Decoder, buffers, register); assertTrue(nullableUInt32Decoder.isReady()); assertTrue(nullableUInt32Decoder.isOverlong()); - assertEquals(942755, nullableUInt32Decoder.getValue()); + assertEquals(942755, register.uInt32Value); } @WithByteBuf("00 40 81") - void nullableNotOverlong(Collection buffers) throws IOException { - decode(nullableUInt32Decoder, buffers); + void nullableNotOverlong(Collection buffers) { + decode(nullableUInt32Decoder, buffers, register); assertTrue(nullableUInt32Decoder.isReady()); assertFalse(nullableUInt32Decoder.isOverlong()); - assertEquals(8192, nullableUInt32Decoder.getValue()); + assertEquals(8192, register.uInt32Value); } } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java index 04f61ae2..171298a9 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java @@ -16,10 +16,10 @@ package com.exactpro.epfast.decoder.integer; +import com.exactpro.epfast.decoder.message.UnionRegister; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; -import java.io.IOException; import java.math.BigInteger; import java.util.Collection; @@ -32,164 +32,166 @@ class TestUInt64 { private DecodeMandatoryUInt64 mandatoryUInt64Decoder = new DecodeMandatoryUInt64(); + private UnionRegister register = new UnionRegister(); + @WithByteBuf("80") - void testNull(Collection buffers) throws IOException { - decode(nullableUInt64Decoder, buffers); + void testNull(Collection buffers) { + decode(nullableUInt64Decoder, buffers, register); assertTrue(nullableUInt64Decoder.isReady()); - assertNull(nullableUInt64Decoder.getValue()); + assertTrue(register.isNull); } @WithByteBuf("81") - void optionalZero(Collection buffers) throws IOException { - decode(nullableUInt64Decoder, buffers); + void optionalZero(Collection buffers) { + decode(nullableUInt64Decoder, buffers, register); assertTrue(nullableUInt64Decoder.isReady()); - assertEquals(new BigInteger("0"), nullableUInt64Decoder.getValue()); + assertEquals(new BigInteger("0"), register.unsignedInt64Value); } @WithByteBuf("80") - void mandatoryZero(Collection buffers) throws IOException { - decode(mandatoryUInt64Decoder, buffers); + void mandatoryZero(Collection buffers) { + decode(mandatoryUInt64Decoder, buffers, register); assertTrue(mandatoryUInt64Decoder.isReady()); - assertEquals(new BigInteger("0"), mandatoryUInt64Decoder.getValue()); + assertEquals(new BigInteger("0"), register.unsignedInt64Value); } @WithByteBuf("02 00 00 00 00 00 00 00 00 80") - void testMaxNullable(Collection buffers) throws IOException { - decode(nullableUInt64Decoder, buffers); + void testMaxNullable(Collection buffers) { + decode(nullableUInt64Decoder, buffers, register); assertTrue(nullableUInt64Decoder.isReady()); - assertEquals(new BigInteger("18446744073709551615"), nullableUInt64Decoder.getValue()); + assertEquals(new BigInteger("18446744073709551615"), register.unsignedInt64Value); } @WithByteBuf("01 7f 7f 7f 7f 7f 7f 7f 7f ff") - void testMaxMandatory(Collection buffers) throws IOException { - decode(mandatoryUInt64Decoder, buffers); + void testMaxMandatory(Collection buffers) { + decode(mandatoryUInt64Decoder, buffers, register); assertTrue(mandatoryUInt64Decoder.isReady()); - assertEquals(new BigInteger("18446744073709551615"), mandatoryUInt64Decoder.getValue()); + assertEquals(new BigInteger("18446744073709551615"), register.unsignedInt64Value); } @WithByteBuf("02 00 00 00 00 00 00 00 00 81") void testMaxOverflowNullable1(Collection buffers) { - decode(nullableUInt64Decoder, buffers); + decode(nullableUInt64Decoder, buffers, register); assertTrue(nullableUInt64Decoder.isReady()); - assertThrows(IOException.class, () -> nullableUInt64Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("02 00 00 00 00 00 00 00 00 00 80") void testMaxOverflowNullable2(Collection buffers) { - decode(nullableUInt64Decoder, buffers); + decode(nullableUInt64Decoder, buffers, register); assertTrue(nullableUInt64Decoder.isReady()); - assertThrows(IOException.class, () -> nullableUInt64Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("02 00 00 00 00 00 00 00 00 80") void testMaxOverflowMandatory1(Collection buffers) { - decode(mandatoryUInt64Decoder, buffers); + decode(mandatoryUInt64Decoder, buffers, register); assertTrue(mandatoryUInt64Decoder.isReady()); - assertThrows(IOException.class, () -> mandatoryUInt64Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("01 7f 7f 7f 7f 00 7f 7f 7f 7f ff") void testMaxOverflowMandatory2(Collection buffers) { - decode(mandatoryUInt64Decoder, buffers); + decode(mandatoryUInt64Decoder, buffers, register); assertTrue(mandatoryUInt64Decoder.isReady()); - assertThrows(IOException.class, () -> mandatoryUInt64Decoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("39 45 a4") - void optionalSimpleNumber1(Collection buffers) throws IOException { - decode(nullableUInt64Decoder, buffers); + void optionalSimpleNumber1(Collection buffers) { + decode(nullableUInt64Decoder, buffers, register); assertTrue(nullableUInt64Decoder.isReady()); - assertEquals(new BigInteger("942755"), nullableUInt64Decoder.getValue()); + assertEquals(new BigInteger("942755"), register.unsignedInt64Value); } @WithByteBuf("01 7f 7f 7f 7f 7f 7f 7f 7f ff") - void optionalSimpleNumber2(Collection buffers) throws IOException { - decode(nullableUInt64Decoder, buffers); + void optionalSimpleNumber2(Collection buffers) { + decode(nullableUInt64Decoder, buffers, register); assertTrue(nullableUInt64Decoder.isReady()); - assertEquals(new BigInteger("18446744073709551614"), nullableUInt64Decoder.getValue()); + assertEquals(new BigInteger("18446744073709551614"), register.unsignedInt64Value); } @WithByteBuf("39 45 a3") - void mandatorySimpleNumber1(Collection buffers) throws IOException { - decode(mandatoryUInt64Decoder, buffers); + void mandatorySimpleNumber1(Collection buffers) { + decode(mandatoryUInt64Decoder, buffers, register); assertTrue(mandatoryUInt64Decoder.isReady()); - assertEquals(new BigInteger("942755"), mandatoryUInt64Decoder.getValue()); + assertEquals(new BigInteger("942755"), register.unsignedInt64Value); } @WithByteBuf("01 10 78 20 76 62 2a 62 51 cf") - void mandatorySimpleNumber2(Collection buffers) throws IOException { - decode(mandatoryUInt64Decoder, buffers); + void mandatorySimpleNumber2(Collection buffers) { + decode(mandatoryUInt64Decoder, buffers, register); assertTrue(mandatoryUInt64Decoder.isReady()); - assertEquals(new BigInteger("10443992354206034127"), mandatoryUInt64Decoder.getValue()); + assertEquals(new BigInteger("10443992354206034127"), register.unsignedInt64Value); } @WithByteBuf("39 45 a4") - void optionalSimpleNumber1GetValueTwice(Collection buffers) throws IOException { - decode(nullableUInt64Decoder, buffers); + void optionalSimpleNumber1GetValueTwice(Collection buffers) { + decode(nullableUInt64Decoder, buffers, register); assertTrue(nullableUInt64Decoder.isReady()); - assertEquals(new BigInteger("942755"), nullableUInt64Decoder.getValue()); - assertEquals(new BigInteger("942755"), nullableUInt64Decoder.getValue()); + assertEquals(new BigInteger("942755"), register.unsignedInt64Value); + assertEquals(new BigInteger("942755"), register.unsignedInt64Value); } @WithByteBuf("39 45 a3") - void mandatorySimpleNumber1GetValueTwice(Collection buffers) throws IOException { - decode(mandatoryUInt64Decoder, buffers); + void mandatorySimpleNumber1GetValueTwice(Collection buffers) { + decode(mandatoryUInt64Decoder, buffers, register); assertTrue(mandatoryUInt64Decoder.isReady()); - assertEquals(new BigInteger("942755"), mandatoryUInt64Decoder.getValue()); - assertEquals(new BigInteger("942755"), mandatoryUInt64Decoder.getValue()); + assertEquals(new BigInteger("942755"), register.unsignedInt64Value); + assertEquals(new BigInteger("942755"), register.unsignedInt64Value); } @WithByteBuf("39 45 a4 01 7f 7f 7f 7f 7f 7f 7f 7f ff") - void optionalSimpleNumbersTwoValuesInRow(Collection buffers) throws IOException { - decode(nullableUInt64Decoder, buffers); + void optionalSimpleNumbersTwoValuesInRow(Collection buffers) { + decode(nullableUInt64Decoder, buffers, register); assertTrue(nullableUInt64Decoder.isReady()); - assertEquals(new BigInteger("942755"), nullableUInt64Decoder.getValue()); + assertEquals(new BigInteger("942755"), register.unsignedInt64Value); - decode(nullableUInt64Decoder, buffers); + decode(nullableUInt64Decoder, buffers, register); assertTrue(nullableUInt64Decoder.isReady()); - assertEquals(new BigInteger("18446744073709551614"), nullableUInt64Decoder.getValue()); + assertEquals(new BigInteger("18446744073709551614"), register.unsignedInt64Value); } @WithByteBuf("39 45 a3 01 10 78 20 76 62 2a 62 51 cf") - void mandatorySimpleNumbersTwoValuesInRow(Collection buffers) throws IOException { - decode(mandatoryUInt64Decoder, buffers); + void mandatorySimpleNumbersTwoValuesInRow(Collection buffers) { + decode(mandatoryUInt64Decoder, buffers, register); assertTrue(mandatoryUInt64Decoder.isReady()); - assertEquals(new BigInteger("942755"), mandatoryUInt64Decoder.getValue()); + assertEquals(new BigInteger("942755"), register.unsignedInt64Value); - decode(mandatoryUInt64Decoder, buffers); + decode(mandatoryUInt64Decoder, buffers, register); assertTrue(mandatoryUInt64Decoder.isReady()); - assertEquals(new BigInteger("10443992354206034127"), mandatoryUInt64Decoder.getValue()); + assertEquals(new BigInteger("10443992354206034127"), register.unsignedInt64Value); } @WithByteBuf("00 39 45 a4") - void mandatoryOverlong(Collection buffers) throws IOException { - decode(mandatoryUInt64Decoder, buffers); + void mandatoryOverlong(Collection buffers) { + decode(mandatoryUInt64Decoder, buffers, register); assertTrue(mandatoryUInt64Decoder.isReady()); assertTrue(mandatoryUInt64Decoder.isOverlong()); - assertEquals(new BigInteger("942756"), mandatoryUInt64Decoder.getValue()); + assertEquals(new BigInteger("942756"), register.unsignedInt64Value); } @WithByteBuf("00 40 81") - void mandatoryNotOverlong(Collection buffers) throws IOException { - decode(mandatoryUInt64Decoder, buffers); + void mandatoryNotOverlong(Collection buffers) { + decode(mandatoryUInt64Decoder, buffers, register); assertTrue(mandatoryUInt64Decoder.isReady()); assertFalse(mandatoryUInt64Decoder.isOverlong()); - assertEquals(new BigInteger("8193"), mandatoryUInt64Decoder.getValue()); + assertEquals(new BigInteger("8193"), register.unsignedInt64Value); } @WithByteBuf("00 39 45 a4") - void nullableOverlong(Collection buffers) throws IOException { - decode(nullableUInt64Decoder, buffers); + void nullableOverlong(Collection buffers) { + decode(nullableUInt64Decoder, buffers, register); assertTrue(nullableUInt64Decoder.isReady()); assertTrue(nullableUInt64Decoder.isOverlong()); - assertEquals(new BigInteger("942755"), nullableUInt64Decoder.getValue()); + assertEquals(new BigInteger("942755"), register.unsignedInt64Value); } @WithByteBuf("00 40 81") - void nullableNotOverlong(Collection buffers) throws IOException { - decode(nullableUInt64Decoder, buffers); + void nullableNotOverlong(Collection buffers) { + decode(nullableUInt64Decoder, buffers, register); assertTrue(nullableUInt64Decoder.isReady()); assertFalse(nullableUInt64Decoder.isOverlong()); - assertEquals(new BigInteger("8192"), nullableUInt64Decoder.getValue()); + assertEquals(new BigInteger("8192"), register.unsignedInt64Value); } } diff --git a/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java b/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java index 95ed82b2..f54fceef 100644 --- a/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java +++ b/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java @@ -16,6 +16,7 @@ package com.exactpro.epfast.decoder.presencemap; +import com.exactpro.epfast.decoder.message.UnionRegister; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; @@ -27,11 +28,13 @@ class TestDecodePresenceMap { private DecodePresenceMap presenceMapDecoder = new DecodePresenceMap(); + + private UnionRegister register = new UnionRegister(); @WithByteBuf("95") //0b10010101 void testSingleByte(Collection buffers) { - decode(presenceMapDecoder, buffers); - PresenceMap presenceMap = presenceMapDecoder.getValue(); + decode(presenceMapDecoder, buffers, register); + PresenceMap presenceMap = register.presenceMap; assertTrue(presenceMap.getValue(0)); assertFalse(presenceMap.getValue(1)); assertTrue(presenceMap.getValue(2)); @@ -43,9 +46,9 @@ void testSingleByte(Collection buffers) { @WithByteBuf("15 15 00 00 00 80") void testOverlong(Collection buffers) { - decode(presenceMapDecoder, buffers); + decode(presenceMapDecoder, buffers, register); assertTrue(presenceMapDecoder.isReady()); - PresenceMap presenceMap = presenceMapDecoder.getValue(); + PresenceMap presenceMap = register.presenceMap; assertTrue(presenceMap.getValue(0)); assertFalse(presenceMap.getValue(1)); assertTrue(presenceMap.getValue(2)); @@ -58,9 +61,9 @@ void testOverlong(Collection buffers) { @WithByteBuf("15 15 00 00 00 82") void testTruncateWhenNotOverlong(Collection buffers) { - decode(presenceMapDecoder, buffers); + decode(presenceMapDecoder, buffers, register); assertTrue(presenceMapDecoder.isReady()); - PresenceMap presenceMap = presenceMapDecoder.getValue(); + PresenceMap presenceMap = register.presenceMap; assertTrue(presenceMap.getValue(0)); assertFalse(presenceMap.getValue(1)); assertTrue(presenceMap.getValue(2)); diff --git a/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java b/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java index 8226bc5f..537ddd36 100644 --- a/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java +++ b/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java @@ -16,10 +16,10 @@ package com.exactpro.epfast.decoder.unicode; +import com.exactpro.epfast.decoder.message.UnionRegister; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; -import java.io.IOException; import java.nio.charset.StandardCharsets; import java.util.Collection; @@ -32,104 +32,106 @@ class TestDecodeByteVector { private DecodeMandatoryByteVector mandatoryByteVectorDecoder = new DecodeMandatoryByteVector(); + private UnionRegister register = new UnionRegister(); + @WithByteBuf("80") - void testNull(Collection buffers) throws IOException { - decode(nullableByteVectorDecoder, buffers); + void testNull(Collection buffers) { + decode(nullableByteVectorDecoder, buffers, register); assertTrue(nullableByteVectorDecoder.isReady()); - assertNull(nullableByteVectorDecoder.getValue()); + assertNull(register.byteVectorValue); } @WithByteBuf("81") - void testNullableZeroLen(Collection buffers) throws IOException { - decode(nullableByteVectorDecoder, buffers); + void testNullableZeroLen(Collection buffers) { + decode(nullableByteVectorDecoder, buffers, register); assertTrue(nullableByteVectorDecoder.isReady()); - assertEquals("", new String(nullableByteVectorDecoder.getValue(), StandardCharsets.UTF_8)); + assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("80") - void testMandatoryZeroLen(Collection buffers) throws IOException { - decode(mandatoryByteVectorDecoder, buffers); + void testMandatoryZeroLen(Collection buffers) { + decode(mandatoryByteVectorDecoder, buffers, register); assertTrue(mandatoryByteVectorDecoder.isReady()); - assertEquals("", new String(mandatoryByteVectorDecoder.getValue(), StandardCharsets.UTF_8)); + assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("10 00 00 00 81 41 42 42 43 44 45") void testNullableLengthOverflow1(Collection buffers) { - decode(nullableByteVectorDecoder, buffers); + decode(nullableByteVectorDecoder, buffers, register); assertTrue(nullableByteVectorDecoder.isReady()); - assertThrows(IOException.class, () -> nullableByteVectorDecoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("10 00 00 00 00 00 80 41 42 42 43 44 45") void testNullableLengthOverflow2(Collection buffers) { - decode(nullableByteVectorDecoder, buffers); + decode(nullableByteVectorDecoder, buffers, register); assertTrue(nullableByteVectorDecoder.isReady()); - assertThrows(IOException.class, () -> nullableByteVectorDecoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("10 00 00 00 80 41 42 42 43 44 45") void testMandatoryLengthOverflow1(Collection buffers) { - decode(mandatoryByteVectorDecoder, buffers); + decode(mandatoryByteVectorDecoder, buffers, register); assertTrue(mandatoryByteVectorDecoder.isReady()); - assertThrows(IOException.class, () -> mandatoryByteVectorDecoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("0f 7f 7f 7f 7f 00 ff 41 42 42 43 44 45") void testMandatoryLengthOverflow2(Collection buffers) { - decode(mandatoryByteVectorDecoder, buffers); + decode(mandatoryByteVectorDecoder, buffers, register); assertTrue(mandatoryByteVectorDecoder.isReady()); - assertThrows(IOException.class, () -> mandatoryByteVectorDecoder.getValue()); + assertTrue(register.isOverflow); } @WithByteBuf("87 41 42 42 43 44 45") - void testSimpleNullableVector(Collection buffers) throws IOException { - decode(nullableByteVectorDecoder, buffers); + void testSimpleNullableVector(Collection buffers) { + decode(nullableByteVectorDecoder, buffers, register); assertTrue(nullableByteVectorDecoder.isReady()); - assertEquals("ABBCDE", new String(nullableByteVectorDecoder.getValue(), StandardCharsets.UTF_8)); + assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("86 41 42 42 43 44 45") - void testSimpleMandatoryVector(Collection buffers) throws IOException { - decode(mandatoryByteVectorDecoder, buffers); + void testSimpleMandatoryVector(Collection buffers) { + decode(mandatoryByteVectorDecoder, buffers, register); assertTrue(mandatoryByteVectorDecoder.isReady()); - assertEquals("ABBCDE", new String(mandatoryByteVectorDecoder.getValue(), StandardCharsets.UTF_8)); + assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("81") - void testNullableZeroLenGetValueTwice(Collection buffers) throws IOException { - decode(nullableByteVectorDecoder, buffers); + void testNullableZeroLenGetValueTwice(Collection buffers) { + decode(nullableByteVectorDecoder, buffers, register); assertTrue(nullableByteVectorDecoder.isReady()); - assertEquals("", new String(nullableByteVectorDecoder.getValue(), StandardCharsets.UTF_8)); - assertEquals("", new String(nullableByteVectorDecoder.getValue(), StandardCharsets.UTF_8)); + assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); + assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("80") - void testMandatoryZeroLenGetValueTwice(Collection buffers) throws IOException { - decode(mandatoryByteVectorDecoder, buffers); + void testMandatoryZeroLenGetValueTwice(Collection buffers) { + decode(mandatoryByteVectorDecoder, buffers, register); assertTrue(mandatoryByteVectorDecoder.isReady()); - assertEquals("", new String(mandatoryByteVectorDecoder.getValue(), StandardCharsets.UTF_8)); - assertEquals("", new String(mandatoryByteVectorDecoder.getValue(), StandardCharsets.UTF_8)); + assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); + assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("87 41 42 42 43 44 45 81") - void testSimpleNullableVectorTwoValuesInRow(Collection buffers) throws IOException { - decode(nullableByteVectorDecoder, buffers); + void testSimpleNullableVectorTwoValuesInRow(Collection buffers) { + decode(nullableByteVectorDecoder, buffers, register); assertTrue(nullableByteVectorDecoder.isReady()); - assertEquals("ABBCDE", new String(nullableByteVectorDecoder.getValue(), StandardCharsets.UTF_8)); + assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); - decode(nullableByteVectorDecoder, buffers); + decode(nullableByteVectorDecoder, buffers, register); assertTrue(nullableByteVectorDecoder.isReady()); - assertEquals("", new String(nullableByteVectorDecoder.getValue(), StandardCharsets.UTF_8)); + assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("86 41 42 42 43 44 45 80") - void testSimpleMandatoryVectorTwoValuesInRow(Collection buffers) throws IOException { - decode(mandatoryByteVectorDecoder, buffers); + void testSimpleMandatoryVectorTwoValuesInRow(Collection buffers) { + decode(mandatoryByteVectorDecoder, buffers, register); assertTrue(mandatoryByteVectorDecoder.isReady()); - assertEquals("ABBCDE", new String(mandatoryByteVectorDecoder.getValue(), StandardCharsets.UTF_8)); + assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); - decode(mandatoryByteVectorDecoder, buffers); + decode(mandatoryByteVectorDecoder, buffers, register); assertTrue(mandatoryByteVectorDecoder.isReady()); - assertEquals("", new String(mandatoryByteVectorDecoder.getValue(), StandardCharsets.UTF_8)); + assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } } From 343c31fe11083a1f72896f122894f64aabea8947 Mon Sep 17 00:00:00 2001 From: vdonadze Date: Sat, 1 Aug 2020 14:55:29 +0400 Subject: [PATCH 03/20] fixed bug with sequence decoding --- .../epfast/decoder/IDecodeContext.java | 2 + .../decoder/ascii/DecodeAsciiString.java | 8 +++ .../ascii/DecodeMandatoryAsciiString.java | 1 + .../ascii/DecodeNullableAsciiString.java | 1 + .../epfast/decoder/decimal/DecodeDecimal.java | 7 +++ .../decimal/DecodeMandatoryDecimal.java | 2 + .../decimal/DecodeNullableDecimal.java | 2 + .../epfast/decoder/integer/DecodeInteger.java | 7 +++ .../decoder/integer/DecodeMandatoryInt32.java | 2 + .../decoder/integer/DecodeMandatoryInt64.java | 60 ++++++++++--------- .../integer/DecodeMandatoryUInt32.java | 2 + .../integer/DecodeMandatoryUInt64.java | 2 + .../decoder/integer/DecodeNullableInt32.java | 2 + .../decoder/integer/DecodeNullableInt64.java | 2 + .../decoder/integer/DecodeNullableUInt32.java | 2 + .../decoder/integer/DecodeNullableUInt64.java | 2 + .../message/InstructionWithDecoder.java | 8 +-- .../decoder/message/PrimitiveInstruction.java | 1 - .../presencemap/DecodePresenceMap.java | 8 +++ .../decoder/unicode/DecodeByteVector.java | 7 +++ .../unicode/DecodeMandatoryByteVector.java | 2 + .../unicode/DecodeNullableByteVector.java | 2 + 22 files changed, 97 insertions(+), 35 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java index 07a34309..63b021e5 100644 --- a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java +++ b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java @@ -30,4 +30,6 @@ public interface IDecodeContext { boolean isReady(); boolean isOverlong(); + + boolean inProgress(); } diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java index f2778a01..69a63a4b 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java @@ -34,12 +34,15 @@ public abstract class DecodeAsciiString implements IDecodeContext { static final int MAX_ALLOWED_LENGTH = 0x20000; + protected boolean inProgress; + DecodeAsciiString(boolean checkOverlong) { this.checkOverlong = checkOverlong; } public int decode(ByteBuf buf, UnionRegister register) { reset(); + inProgress = true; int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); if (buf.getByte(readerIndex) == 0) { @@ -102,4 +105,9 @@ public final void reset() { zeroCount = 0; zeroPreamble = false; } + + @Override + public boolean inProgress() { + return inProgress; + } } diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java index aa583461..710b13ec 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java @@ -30,6 +30,7 @@ public DecodeMandatoryAsciiString(boolean checkOverlong) { @Override public void setRegisterValue(UnionRegister register) { + inProgress = false; if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { register.isOverflow = true; register.errorMessage = "String is longer than allowed"; diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java index 3b53901a..1b3f68e2 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java @@ -30,6 +30,7 @@ public DecodeNullableAsciiString(boolean checkOverlong) { @Override public void setRegisterValue(UnionRegister register) { + inProgress = false; if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { register.isOverflow = true; register.errorMessage = "String is longer than allowed"; diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java index cc86f4f6..700cb0a8 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java @@ -37,6 +37,8 @@ public abstract class DecodeDecimal implements IDecodeContext { boolean mantissaOverflow; + protected boolean inProgress; + public abstract int decode(ByteBuf buf, UnionRegister register); public abstract int continueDecode(ByteBuf buf, UnionRegister register); @@ -56,4 +58,9 @@ public boolean isReady() { } public abstract boolean isOverlong(); + + @Override + public boolean inProgress() { + return inProgress; + } } diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java index a4e1cc2c..9c1801ff 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java @@ -30,6 +30,7 @@ public final class DecodeMandatoryDecimal extends DecodeDecimal { public int decode(ByteBuf buf, UnionRegister register) { reset(); + inProgress = true; exponentDecoder.decode(buf, register); if (exponentDecoder.isReady()) { exponentReady = true; @@ -113,6 +114,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { } public void setRegisterValue(UnionRegister register) { + inProgress = false; if (exponentOverflow) { register.isOverflow = true; register.errorMessage = "exponent value range is int32"; diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java index fc849537..1dfa52e3 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java @@ -32,6 +32,7 @@ public final class DecodeNullableDecimal extends DecodeDecimal { public int decode(ByteBuf buf, UnionRegister register) { reset(); + inProgress = true; exponentDecoder.decode(buf, register); if (exponentDecoder.isReady()) { exponentReady = true; @@ -126,6 +127,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { @Override public void setRegisterValue(UnionRegister register) { + inProgress = false; if (exponentOverflow) { register.isOverflow = true; register.errorMessage = "exponent value range is int32"; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java index 849fca9c..69bccbbd 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java @@ -44,6 +44,8 @@ public boolean isOverlong() { return overlong; } + protected boolean inProgress; + protected final void reset() { ready = false; overflow = false; @@ -59,4 +61,9 @@ static void longToBytes(long value, byte[] bytes) { } public abstract void setRegisterValue(UnionRegister register); + + @Override + public boolean inProgress() { + return inProgress; + } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java index 48a5a3ca..8e746308 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java @@ -29,6 +29,7 @@ public final class DecodeMandatoryInt32 extends DecodeInteger { public int decode(ByteBuf buf, UnionRegister register) { reset(); + inProgress = true; int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); int oneByte = buf.getByte(readerIndex++); @@ -105,6 +106,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { @Override public void setRegisterValue(UnionRegister register) { + inProgress = false; if (overflow) { register.isOverflow = true; register.errorMessage = "Int32 Overflow"; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java index 244ba46f..57a840bc 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java @@ -27,37 +27,9 @@ public final class DecodeMandatoryInt64 extends DecodeInteger { private long value; - public int continueDecode(ByteBuf buf, UnionRegister register) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (value >= 0) { - if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex)); //continue checking - checkForSignExtension = false; - } - do { - accumulatePositive(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } else { - if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes - checkForSignExtension = false; - } - do { - accumulateNegative(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } - buf.readerIndex(readerIndex); - if (ready) { - setRegisterValue(register); - return 1; - } else { - return 0; - } - } - public int decode(ByteBuf buf, UnionRegister register) { reset(); + inProgress = true; int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); int oneByte = buf.getByte(readerIndex++); @@ -103,8 +75,38 @@ public int decode(ByteBuf buf, UnionRegister register) { } } + public int continueDecode(ByteBuf buf, UnionRegister register) { + int readerIndex = buf.readerIndex(); + int readLimit = buf.writerIndex(); + if (value >= 0) { + if (checkForSignExtension) { + checkOverlongPositive(buf.getByte(readerIndex)); //continue checking + checkForSignExtension = false; + } + do { + accumulatePositive(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } else { + if (checkForSignExtension) { + checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes + checkForSignExtension = false; + } + do { + accumulateNegative(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } + buf.readerIndex(readerIndex); + if (ready) { + setRegisterValue(register); + return 1; + } else { + return 0; + } + } + @Override public void setRegisterValue(UnionRegister register) { + inProgress = false; if (overflow) { register.isOverflow = true; register.errorMessage = "Int64 Overflow"; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java index 4b08dee5..4c0679d9 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java @@ -28,6 +28,7 @@ public final class DecodeMandatoryUInt32 extends DecodeInteger { public int decode(ByteBuf buf, UnionRegister register) { reset(); value = 0; + inProgress = true; int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); int oneByte = buf.getByte(readerIndex++); @@ -75,6 +76,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { @Override public void setRegisterValue(UnionRegister register) { + inProgress = false; if (overflow) { register.isOverflow = true; register.errorMessage = "UInt32 Overflow"; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java index 6c67c5a4..cee87e87 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java @@ -32,6 +32,7 @@ public final class DecodeMandatoryUInt64 extends DecodeInteger { public int decode(ByteBuf buf, UnionRegister register) { reset(); value = 0; + inProgress = true; int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); int oneByte = buf.getByte(readerIndex++); @@ -79,6 +80,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { @Override public void setRegisterValue(UnionRegister register) { + inProgress = false; if (overflow) { register.isOverflow = true; register.errorMessage = "UInt32 Overflow"; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java index ffa719a9..e4a841f5 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java @@ -31,6 +31,7 @@ public final class DecodeNullableInt32 extends DecodeInteger { public int decode(ByteBuf buf, UnionRegister register) { reset(); + inProgress = true; int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); int oneByte = buf.getByte(readerIndex++); @@ -109,6 +110,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { @Override public void setRegisterValue(UnionRegister register) { + inProgress = false; if (overflow) { register.isOverflow = true; register.errorMessage = "Int32 Overflow"; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java index a0c168ef..ba123b4c 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java @@ -31,6 +31,7 @@ public final class DecodeNullableInt64 extends DecodeInteger { public int decode(ByteBuf buf, UnionRegister register) { reset(); + inProgress = true; int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); int oneByte = buf.getByte(readerIndex++); @@ -109,6 +110,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { @Override public void setRegisterValue(UnionRegister register) { + inProgress = false; if (overflow) { register.isOverflow = true; register.errorMessage = "Int64 Overflow"; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java index cf99d142..30a74fda 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java @@ -31,6 +31,7 @@ public int decode(ByteBuf buf, UnionRegister register) { reset(); value = 0; isUInt32Limit = false; + inProgress = true; int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); int oneByte = buf.getByte(readerIndex++); @@ -78,6 +79,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { @Override public void setRegisterValue(UnionRegister register) { + inProgress = false; if (overflow) { register.isOverflow = true; register.errorMessage = "UInt32 Overflow"; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java index ffd441d6..b439e29f 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java @@ -35,6 +35,7 @@ public int decode(ByteBuf buf, UnionRegister register) { reset(); value = 0; isUInt64Limit = false; + inProgress = true; int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); int oneByte = buf.getByte(readerIndex++); @@ -82,6 +83,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { @Override public void setRegisterValue(UnionRegister register) { + inProgress = false; if (overflow) { register.isOverflow = true; register.errorMessage = "UInt64 Overflow"; diff --git a/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java b/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java index 6200e2e6..f1940371 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java @@ -25,8 +25,6 @@ public abstract class InstructionWithDecoder implement protected T fieldDecoder; - protected boolean decoderStarted; - protected InstructionWithDecoder(T fieldDecoder) { this.fieldDecoder = Objects.requireNonNull(fieldDecoder); } @@ -45,10 +43,10 @@ public int executeOn(DecoderState decoderState) throws OverflowException { decoderState.canProceed = false; return 0; } - if (!decoderStarted) { - return decode(decoderState); + if (!fieldDecoder.inProgress()) { + return decode(decoderState); } else { - return continueDecode(decoderState); + return continueDecode(decoderState); } } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java b/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java index 87b3fa3c..78296ccd 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java @@ -25,7 +25,6 @@ protected PrimitiveInstruction(T fieldDecoder) { } protected int decode(DecoderState decoderState) { - decoderStarted = true; return fieldDecoder.decode(decoderState.inputBuffer, decoderState.register); } diff --git a/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java b/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java index 1554d308..07ad7214 100644 --- a/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java +++ b/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java @@ -32,8 +32,11 @@ public class DecodePresenceMap implements IDecodeContext { private boolean ready; + protected boolean inProgress; + public int decode(ByteBuf buf, UnionRegister register) { reset(); + inProgress = true; continueDecode(buf, register); if (ready) { setRegisterValue(register); @@ -60,6 +63,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { public void setRegisterValue(UnionRegister register) { //TODO add overlong checks for presence map + inProgress = false; register.presenceMap = new PresenceMap((BitSet) value.clone()); } @@ -91,5 +95,9 @@ public final void reset() { lastNonZeroIndex = 0; } + @Override + public boolean inProgress() { + return inProgress; + } } diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java index b74ad6ca..e442a64e 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java @@ -35,6 +35,8 @@ public abstract class DecodeByteVector implements IDecodeContext { boolean overflow; + protected boolean inProgress; + public abstract int decode(ByteBuf buf, UnionRegister register); public abstract int continueDecode(ByteBuf buf, UnionRegister register); @@ -61,6 +63,11 @@ public final void reset() { counter = 0; value = new ArrayList<>(); } + + @Override + public boolean inProgress() { + return inProgress; + } } diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java index f98f235e..722628b9 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java @@ -28,6 +28,7 @@ public final class DecodeMandatoryByteVector extends DecodeByteVector { public int decode(ByteBuf buf, UnionRegister register) { reset(); + inProgress = true; lengthDecoder.decode(buf, register); if (lengthDecoder.isReady()) { lengthReady = true; @@ -112,6 +113,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { @Override public void setRegisterValue(UnionRegister register) { + inProgress = false; if (overflow) { register.isOverflow = true; register.errorMessage = "length value range is uint32"; diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java index 2959be27..d60260e0 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java @@ -28,6 +28,7 @@ public final class DecodeNullableByteVector extends DecodeByteVector { public int decode(ByteBuf buf, UnionRegister register) { reset(); + inProgress = true; lengthDecoder.decode(buf, register); if (lengthDecoder.isReady()) { lengthReady = true; @@ -112,6 +113,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { @Override public void setRegisterValue(UnionRegister register) { + inProgress = false; if (overflow) { register.isOverflow = true; register.errorMessage = "length value range is uint32"; From 9d0061320b2577ab349e50a46e55cade36913b13 Mon Sep 17 00:00:00 2001 From: Anton Sitnikov Date: Tue, 4 Aug 2020 22:43:56 +0400 Subject: [PATCH 04/20] Ascii String decoder test fix; Ascii String decoder rework; --- .../epfast/decoder/IDecodeContext.java | 12 +- .../decoder/ascii/DecodeAsciiString.java | 77 ++--- .../ascii/DecodeMandatoryAsciiString.java | 11 +- .../ascii/DecodeNullableAsciiString.java | 9 +- .../epfast/decoder/decimal/DecodeDecimal.java | 2 +- .../decimal/DecodeMandatoryDecimal.java | 10 +- .../decimal/DecodeNullableDecimal.java | 10 +- .../epfast/decoder/integer/DecodeInteger.java | 2 +- .../decoder/integer/DecodeMandatoryInt32.java | 2 +- .../decoder/integer/DecodeMandatoryInt64.java | 2 +- .../integer/DecodeMandatoryUInt32.java | 2 +- .../integer/DecodeMandatoryUInt64.java | 2 +- .../decoder/integer/DecodeNullableInt32.java | 2 +- .../decoder/integer/DecodeNullableInt64.java | 2 +- .../decoder/integer/DecodeNullableUInt32.java | 2 +- .../decoder/integer/DecodeNullableUInt64.java | 2 +- .../message/InstructionWithDecoder.java | 8 +- .../decoder/message/PrimitiveInstruction.java | 6 +- .../epfast/decoder/message/UnionRegister.java | 2 + .../presencemap/DecodePresenceMap.java | 2 +- .../decoder/unicode/DecodeByteVector.java | 2 +- .../unicode/DecodeMandatoryByteVector.java | 4 +- .../unicode/DecodeNullableByteVector.java | 4 +- .../com/exactpro/epfast/DecoderUtils.java | 6 +- .../decoder/ascii/TestDecodeAsciiString.java | 279 ++++++++++-------- 25 files changed, 243 insertions(+), 219 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java index 63b021e5..a14444ba 100644 --- a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java +++ b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java @@ -20,10 +20,12 @@ import io.netty.buffer.ByteBuf; public interface IDecodeContext { + int FINISHED = 1; + int MORE_DATA_NEEDED = 0; int CLEAR_STOP_BIT_MASK = 0b01111111; - int decode(ByteBuf buf, UnionRegister register); + int startDecode(ByteBuf buf, UnionRegister register); int continueDecode(ByteBuf buf, UnionRegister register); @@ -32,4 +34,12 @@ public interface IDecodeContext { boolean isOverlong(); boolean inProgress(); + + default int decode(ByteBuf buf, UnionRegister register) { + if (!inProgress()) { + return startDecode(buf, register); + } else { + return continueDecode(buf, register); + } + } } diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java index 69a63a4b..530f0fd7 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java @@ -26,7 +26,7 @@ public abstract class DecodeAsciiString implements IDecodeContext { private boolean ready; - boolean zeroPreamble; + boolean decodingPreamble = true; final boolean checkOverlong; @@ -34,80 +34,81 @@ public abstract class DecodeAsciiString implements IDecodeContext { static final int MAX_ALLOWED_LENGTH = 0x20000; - protected boolean inProgress; - DecodeAsciiString(boolean checkOverlong) { this.checkOverlong = checkOverlong; } - public int decode(ByteBuf buf, UnionRegister register) { - reset(); - inProgress = true; - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (buf.getByte(readerIndex) == 0) { - zeroPreamble = true; - } - accumulateValue(buf.getByte(readerIndex++)); - while ((readerIndex < readLimit) && !ready) { - accumulateValue(buf.getByte(readerIndex++)); - } - buf.readerIndex(readerIndex); - if (ready) { - setRegisterValue(register); - return 1; - } else { - return 0; - } + public int startDecode(ByteBuf buf, UnionRegister register) { + throw new UnsupportedOperationException(); } public int continueDecode(ByteBuf buf, UnionRegister register) { + throw new UnsupportedOperationException(); + } + + public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); - while ((readerIndex < readLimit) && !ready) { - accumulateValue(buf.getByte(readerIndex++)); + while (decodingPreamble && !ready && (readerIndex < readLimit)) { + accumulateValue(getPreambleByte(readerIndex++, buf)); + } + while (!ready && (readerIndex < readLimit)) { + accumulateValue(getByte(readerIndex++, buf)); } buf.readerIndex(readerIndex); if (ready) { - setRegisterValue(register); - return 1; + setResult(register); + reset(); + return FINISHED; } else { - return 0; + return MORE_DATA_NEEDED; } } - public abstract void setRegisterValue(UnionRegister unionRegister); + public abstract void setResult(UnionRegister unionRegister); public boolean isReady() { return ready; } public boolean isOverlong() { - return (zeroPreamble && (zeroCount < stringBuilder.length())); + throw new UnsupportedOperationException(); } - private void accumulateValue(int oneByte) { - if (oneByte < 0) { // if stop bit is set - oneByte &= CLEAR_STOP_BIT_MASK; - ready = true; + private int getPreambleByte(int index, ByteBuf buf) { + int aByte = getByte(index, buf); + if (aByte == 0) { + ++zeroCount; + } else { + decodingPreamble = false; } - if (oneByte == 0) { - zeroCount++; + return aByte; + } + + private int getByte(int index, ByteBuf buf) { + int aByte = buf.getByte(index); + if (aByte < 0) { // if stop bit is set + aByte &= CLEAR_STOP_BIT_MASK; + ready = true; } + return aByte; + } + + private void accumulateValue(int aByte) { if (stringBuilder.length() < MAX_ALLOWED_LENGTH) { - stringBuilder.append((char) oneByte); + stringBuilder.append((char) aByte); } } public final void reset() { stringBuilder.setLength(0); ready = false; + decodingPreamble = true; zeroCount = 0; - zeroPreamble = false; } @Override public boolean inProgress() { - return inProgress; + throw new UnsupportedOperationException(); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java index 710b13ec..ab82901d 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java @@ -29,24 +29,19 @@ public DecodeMandatoryAsciiString(boolean checkOverlong) { } @Override - public void setRegisterValue(UnionRegister register) { - inProgress = false; + public void setResult(UnionRegister register) { if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { register.isOverflow = true; register.errorMessage = "String is longer than allowed"; } else if (zeroCount < stringBuilder.length()) { - if (zeroPreamble && checkOverlong) { + if ((zeroCount > 0) && checkOverlong) { register.isOverflow = true; - register.errorMessage = "String with zero preamble can't contain any value except 0"; + register.errorMessage = "String with zero preamble can't contain any value except \\0"; } else { register.isOverflow = false; register.isNull = false; register.stringValue = stringBuilder.toString(); } - } else if (zeroCount == 1) { - register.isOverflow = false; - register.isNull = false; - register.stringValue = ""; } else { stringBuilder.setLength(zeroCount - 1); register.isOverflow = false; diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java index 1b3f68e2..930b5c1c 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java @@ -29,13 +29,12 @@ public DecodeNullableAsciiString(boolean checkOverlong) { } @Override - public void setRegisterValue(UnionRegister register) { - inProgress = false; + public void setResult(UnionRegister register) { if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { register.isOverflow = true; register.errorMessage = "String is longer than allowed"; } else if (zeroCount < stringBuilder.length()) { - if (zeroPreamble && checkOverlong) { + if ((zeroCount > 0) && checkOverlong) { register.isOverflow = true; register.errorMessage = "String with zero preamble can't contain any value except 0"; } else { @@ -46,10 +45,6 @@ public void setRegisterValue(UnionRegister register) { } else if (zeroCount == 1) { register.isOverflow = false; register.stringValue = null; - } else if (zeroCount == 2) { - register.isOverflow = false; - register.isNull = false; - register.stringValue = ""; } else { stringBuilder.setLength(zeroCount - 2); register.isOverflow = false; diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java index 700cb0a8..90b9faca 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java @@ -39,7 +39,7 @@ public abstract class DecodeDecimal implements IDecodeContext { protected boolean inProgress; - public abstract int decode(ByteBuf buf, UnionRegister register); + public abstract int startDecode(ByteBuf buf, UnionRegister register); public abstract int continueDecode(ByteBuf buf, UnionRegister register); diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java index 9c1801ff..7406d8a6 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java @@ -28,10 +28,10 @@ public final class DecodeMandatoryDecimal extends DecodeDecimal { private int exponent; - public int decode(ByteBuf buf, UnionRegister register) { + public int startDecode(ByteBuf buf, UnionRegister register) { reset(); inProgress = true; - exponentDecoder.decode(buf, register); + exponentDecoder.startDecode(buf, register); if (exponentDecoder.isReady()) { exponentReady = true; if (register.isOverflow) { @@ -40,7 +40,7 @@ public int decode(ByteBuf buf, UnionRegister register) { exponent = register.int32Value; } if (buf.isReadable()) { - mantissaDecoder.decode(buf, register); + mantissaDecoder.startDecode(buf, register); startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; @@ -72,7 +72,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { } } } else if (exponentReady) { - mantissaDecoder.decode(buf, register); + mantissaDecoder.startDecode(buf, register); startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; @@ -92,7 +92,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { exponent = register.int32Value; } if (buf.isReadable()) { - mantissaDecoder.decode(buf, register); + mantissaDecoder.startDecode(buf, register); startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java index 1dfa52e3..4abdb2bf 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java @@ -30,10 +30,10 @@ public final class DecodeNullableDecimal extends DecodeDecimal { private boolean nullValue; - public int decode(ByteBuf buf, UnionRegister register) { + public int startDecode(ByteBuf buf, UnionRegister register) { reset(); inProgress = true; - exponentDecoder.decode(buf, register); + exponentDecoder.startDecode(buf, register); if (exponentDecoder.isReady()) { exponentReady = true; if (register.isOverflow) { @@ -42,7 +42,7 @@ public int decode(ByteBuf buf, UnionRegister register) { exponent = register.int32Value; } if (!register.isNull && buf.isReadable()) { - mantissaDecoder.decode(buf, register); + mantissaDecoder.startDecode(buf, register); startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; @@ -80,7 +80,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { } } else if (exponentReady) { startedMantissa = true; - mantissaDecoder.decode(buf, register); + mantissaDecoder.startDecode(buf, register); if (mantissaDecoder.isReady()) { ready = true; if (register.isOverflow) { @@ -99,7 +99,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { exponent = register.int32Value; } if (!register.isNull && buf.isReadable()) { - mantissaDecoder.decode(buf, register); + mantissaDecoder.startDecode(buf, register); startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java index 69bccbbd..4af7df83 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java @@ -32,7 +32,7 @@ public abstract class DecodeInteger implements IDecodeContext { boolean checkForSignExtension = false; - public abstract int decode(ByteBuf buf, UnionRegister register); + public abstract int startDecode(ByteBuf buf, UnionRegister register); public abstract int continueDecode(ByteBuf buf, UnionRegister register); diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java index 8e746308..94091b49 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java @@ -27,7 +27,7 @@ public final class DecodeMandatoryInt32 extends DecodeInteger { private int value; - public int decode(ByteBuf buf, UnionRegister register) { + public int startDecode(ByteBuf buf, UnionRegister register) { reset(); inProgress = true; int readerIndex = buf.readerIndex(); diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java index 57a840bc..dc51f067 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java @@ -27,7 +27,7 @@ public final class DecodeMandatoryInt64 extends DecodeInteger { private long value; - public int decode(ByteBuf buf, UnionRegister register) { + public int startDecode(ByteBuf buf, UnionRegister register) { reset(); inProgress = true; int readerIndex = buf.readerIndex(); diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java index 4c0679d9..636e5f90 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java @@ -25,7 +25,7 @@ public final class DecodeMandatoryUInt32 extends DecodeInteger { private int value; - public int decode(ByteBuf buf, UnionRegister register) { + public int startDecode(ByteBuf buf, UnionRegister register) { reset(); value = 0; inProgress = true; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java index cee87e87..9dbb99ba 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java @@ -29,7 +29,7 @@ public final class DecodeMandatoryUInt64 extends DecodeInteger { private long value; - public int decode(ByteBuf buf, UnionRegister register) { + public int startDecode(ByteBuf buf, UnionRegister register) { reset(); value = 0; inProgress = true; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java index e4a841f5..71f059b1 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java @@ -29,7 +29,7 @@ public final class DecodeNullableInt32 extends DecodeInteger { private int value; - public int decode(ByteBuf buf, UnionRegister register) { + public int startDecode(ByteBuf buf, UnionRegister register) { reset(); inProgress = true; int readerIndex = buf.readerIndex(); diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java index ba123b4c..3da10f37 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java @@ -29,7 +29,7 @@ public final class DecodeNullableInt64 extends DecodeInteger { private long value; - public int decode(ByteBuf buf, UnionRegister register) { + public int startDecode(ByteBuf buf, UnionRegister register) { reset(); inProgress = true; int readerIndex = buf.readerIndex(); diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java index 30a74fda..696197e7 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java @@ -27,7 +27,7 @@ public final class DecodeNullableUInt32 extends DecodeInteger { private int value; - public int decode(ByteBuf buf, UnionRegister register) { + public int startDecode(ByteBuf buf, UnionRegister register) { reset(); value = 0; isUInt32Limit = false; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java index b439e29f..40ee547e 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java @@ -31,7 +31,7 @@ public final class DecodeNullableUInt64 extends DecodeInteger { private long value; - public int decode(ByteBuf buf, UnionRegister register) { + public int startDecode(ByteBuf buf, UnionRegister register) { reset(); value = 0; isUInt64Limit = false; diff --git a/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java b/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java index f1940371..223cde1a 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java @@ -31,8 +31,6 @@ protected InstructionWithDecoder(T fieldDecoder) { protected abstract int decode(DecoderState decoderState) throws OverflowException; - protected abstract int continueDecode(DecoderState decoderState) throws OverflowException; - public boolean isReady() { return fieldDecoder.isReady(); } @@ -43,10 +41,6 @@ public int executeOn(DecoderState decoderState) throws OverflowException { decoderState.canProceed = false; return 0; } - if (!fieldDecoder.inProgress()) { - return decode(decoderState); - } else { - return continueDecode(decoderState); - } + return decode(decoderState); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java b/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java index 78296ccd..97fb30de 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java @@ -25,10 +25,6 @@ protected PrimitiveInstruction(T fieldDecoder) { } protected int decode(DecoderState decoderState) { - return fieldDecoder.decode(decoderState.inputBuffer, decoderState.register); - } - - protected int continueDecode(DecoderState decoderState) { - return fieldDecoder.continueDecode(decoderState.inputBuffer, decoderState.register); + return fieldDecoder.startDecode(decoderState.inputBuffer, decoderState.register); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java b/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java index ad8baf14..f2fa466d 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java @@ -28,6 +28,8 @@ public class UnionRegister { public boolean isOverflow; + public boolean isOverlong; + public int int32Value; public long uInt32Value; diff --git a/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java b/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java index 07ad7214..1e3131d2 100644 --- a/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java +++ b/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java @@ -34,7 +34,7 @@ public class DecodePresenceMap implements IDecodeContext { protected boolean inProgress; - public int decode(ByteBuf buf, UnionRegister register) { + public int startDecode(ByteBuf buf, UnionRegister register) { reset(); inProgress = true; continueDecode(buf, register); diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java index e442a64e..61a4a7b7 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java @@ -37,7 +37,7 @@ public abstract class DecodeByteVector implements IDecodeContext { protected boolean inProgress; - public abstract int decode(ByteBuf buf, UnionRegister register); + public abstract int startDecode(ByteBuf buf, UnionRegister register); public abstract int continueDecode(ByteBuf buf, UnionRegister register); diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java index 722628b9..81556815 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java @@ -26,10 +26,10 @@ public final class DecodeMandatoryByteVector extends DecodeByteVector { private long messageLength; - public int decode(ByteBuf buf, UnionRegister register) { + public int startDecode(ByteBuf buf, UnionRegister register) { reset(); inProgress = true; - lengthDecoder.decode(buf, register); + lengthDecoder.startDecode(buf, register); if (lengthDecoder.isReady()) { lengthReady = true; if (register.isOverflow) { diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java index d60260e0..c2dfd1a1 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java @@ -26,10 +26,10 @@ public final class DecodeNullableByteVector extends DecodeByteVector { private long messageLength; - public int decode(ByteBuf buf, UnionRegister register) { + public int startDecode(ByteBuf buf, UnionRegister register) { reset(); inProgress = true; - lengthDecoder.decode(buf, register); + lengthDecoder.startDecode(buf, register); if (lengthDecoder.isReady()) { lengthReady = true; if (register.isOverflow) { diff --git a/src/test/java/com/exactpro/epfast/DecoderUtils.java b/src/test/java/com/exactpro/epfast/DecoderUtils.java index df91506b..5e6fce86 100644 --- a/src/test/java/com/exactpro/epfast/DecoderUtils.java +++ b/src/test/java/com/exactpro/epfast/DecoderUtils.java @@ -21,14 +21,14 @@ import io.netty.buffer.ByteBuf; import java.util.Iterator; +import java.util.function.Consumer; +import java.util.function.Function; public class DecoderUtils { public static void decode(IDecodeContext decoder, Iterable buffers, UnionRegister register) { Iterator it = buffers.iterator(); - decoder.decode(nextNonEmptyBuffer(it), register); - while (!decoder.isReady()) { - decoder.continueDecode(nextNonEmptyBuffer(it), register); + while (decoder.decode(nextNonEmptyBuffer(it), register) == IDecodeContext.MORE_DATA_NEEDED) { } } diff --git a/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java b/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java index b16e836f..92c9835e 100644 --- a/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java +++ b/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java @@ -31,7 +31,7 @@ class TestDecodeAsciiString { - private UnionRegister register = new UnionRegister(); + private final UnionRegister decodeResult = new UnionRegister(); static String fastAsciiStringOf(char character, int length) { if (character > 0 && character < 128) { @@ -46,190 +46,221 @@ static String fastAsciiStringOf(char character, int length) { } @Nested - class TestNullable { - - private DecodeNullableAsciiString decoder = new DecodeNullableAsciiString(); + class TestOptional { + private final DecodeNullableAsciiString decoder = new DecodeNullableAsciiString(); @WithByteBuf("80") - void testNull(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertNull(register.stringValue); - assertFalse(decoder.isOverlong()); + void testNull(Collection buffers) { + decodeResult.isOverflow = true; + decodeResult.isNull = false; + decodeResult.isOverlong = true; + decodeResult.stringValue = ""; + + decode(decoder, buffers, decodeResult); + + assertFalse(decodeResult.isOverflow); + assertTrue(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertNull(decodeResult.stringValue); } @WithByteBuf("00 80") - void testOptionalEmptyString(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertEquals("", register.stringValue); - assertFalse(decoder.isOverlong()); + void testOptionalEmptyString(Collection buffers) { + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("", decodeResult.stringValue); } @WithByteBuf("41 42 c3") - void testSimpleString(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertEquals("ABC", register.stringValue); - assertFalse(decoder.isOverlong()); + void testOptionalSimpleString(Collection buffers) { + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("ABC", decodeResult.stringValue); } - @WithByteBuf("00 00 80") - void testZeroByteStringNullable1(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertEquals("\0", register.stringValue); - assertFalse(decoder.isOverlong()); + @WithByteBuf("00 C1") + void testOptionalOverlongString1(Collection buffers) { + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertTrue(decodeResult.isOverlong); + assertEquals("A", decodeResult.stringValue); } - @WithByteBuf("00 00 00 00 80") - void testZeroByteStringNullable2(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertEquals("\0\0\0", register.stringValue); - assertFalse(decoder.isOverlong()); + @WithByteBuf("00 00 C1") + void testOptionalOverlongString2(Collection buffers) { + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertTrue(decodeResult.isOverlong); + assertEquals("A", decodeResult.stringValue); } - @WithByteBuf("41 42 c3 42 42 c3 41 44 c3") - void testNullableReuse(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertFalse(decoder.isOverlong()); - assertEquals("ABC", register.stringValue); - decode(decoder, buffers, register); - assertEquals("BBC", register.stringValue); - decode(decoder, buffers, register); - assertEquals("ADC", register.stringValue); + @WithByteBuf("00 00 00 00 80") + void testOptionalStringAllZeros(Collection buffers) { + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("\0\0\0", decodeResult.stringValue); } - @WithByteBuf("41 42 c3") - void testSimpleStringGetValueTwice(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertFalse(decoder.isOverlong()); - assertEquals("ABC", register.stringValue); - assertEquals("ABC", register.stringValue); + @WithByteBuf("41 42 c3 42 42 c3 41 44 c3") + void testOptionalStringDecoderReuse(Collection buffers) { + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("ABC", decodeResult.stringValue); + + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("BBC", decodeResult.stringValue); + + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("ADC", decodeResult.stringValue); } - @WithByteBuf("00 00 00 81") - void testNullableOverlongNoException(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertTrue(decoder.isOverlong()); + @WithByteBuf("00 00 00 C1") + void testOptionalStringStartedWithZero(Collection buffers) { + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("\0A", decodeResult.stringValue); } @Nested class TestOverflowException { - - private DecodeNullableAsciiString decoder = new DecodeNullableAsciiString(true); - - @WithByteBuf("00 00 00 81") - void testNullableOverlong1(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertTrue(decoder.isOverlong()); - assertTrue(register.isOverflow); + private final DecodeNullableAsciiString decoder = new DecodeNullableAsciiString(true); + + @WithByteBuf("00 00 00 C1") + void testOptionalOverlong1(Collection buffers) { + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertTrue(decodeResult.isOverlong); + assertEquals("\0A", decodeResult.stringValue); } @Test - void testNullableOverlong2() { - decoder.decode(fromHex(fastAsciiStringOf(')', 2 * DecodeAsciiString.MAX_ALLOWED_LENGTH)), register); - assertTrue(decoder.isReady()); - assertTrue(register.isOverflow); + void testOptionalOverlong2() { + decoder.decode( + fromHex(fastAsciiStringOf(')', 2 * DecodeAsciiString.MAX_ALLOWED_LENGTH)), + decodeResult); + assertTrue(decodeResult.isOverflow); } } @WithByteBuf("00 00 80 00 00 00 00 80") - void testZeroByteStringNullableTwoValuesInRow(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertFalse(decoder.isOverlong()); - assertEquals("\0", register.stringValue); - - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertFalse(decoder.isOverlong()); - assertEquals("\0\0\0", register.stringValue); + void testOptionalStringTwoValuesInRow(Collection buffers) { + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("\0", decodeResult.stringValue); + + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("\0\0\0", decodeResult.stringValue); } } @Nested class TestMandatory { - - private DecodeMandatoryAsciiString decoder = new DecodeMandatoryAsciiString(); + private final DecodeMandatoryAsciiString decoder = new DecodeMandatoryAsciiString(); @WithByteBuf("80") void testMandatoryEmptyString(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertFalse(decoder.isOverlong()); - assertEquals("", register.stringValue); + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("", decodeResult.stringValue); } @WithByteBuf("00 00 80") - void testZeroByteStringMandatory1(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertFalse(decoder.isOverlong()); - assertEquals("\0\0", register.stringValue); + void testMandatoryStringAllZeros1(Collection buffers) { + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("\0\0", decodeResult.stringValue); } @WithByteBuf("00 00 00 00 80") - void testZeroByteStringMandatory2(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertFalse(decoder.isOverlong()); - assertEquals("\0\0\0\0", register.stringValue); + void testMandatoryStringAllZeros2(Collection buffers) { + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("\0\0\0\0", decodeResult.stringValue); } - @WithByteBuf("80") - void testMandatoryEmptyStringGetValueTwice(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertFalse(decoder.isOverlong()); - assertEquals("", register.stringValue); - assertEquals("", register.stringValue); + @WithByteBuf("00 C1") + void testMandatoryOverlongString(Collection buffers) { + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertTrue(decodeResult.isOverlong); + assertEquals("A", decodeResult.stringValue); } - @WithByteBuf("00 00 00 81") - void testMandatoryOverlongNoException(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertTrue(decoder.isOverlong()); + @WithByteBuf("00 00 C1") + void testMandatoryStringStartedWithZero(Collection buffers) { + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("\0A", decodeResult.stringValue); } @Nested class TestOverflowException { + private final DecodeMandatoryAsciiString decoder = new DecodeMandatoryAsciiString(true); - private DecodeMandatoryAsciiString decoder = new DecodeMandatoryAsciiString(true); - - @WithByteBuf("00 81") + @WithByteBuf("00 C1") void testMandatoryOverlong1(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertTrue(decoder.isOverlong()); - assertTrue(register.isOverflow); + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertTrue(decodeResult.isOverlong); + assertEquals("A", decodeResult.stringValue); } @Test void testMandatoryOverlong2() { - decoder.decode(fromHex(fastAsciiStringOf('*', 3 * DecodeAsciiString.MAX_ALLOWED_LENGTH)), register); - assertTrue(decoder.isReady()); - assertTrue(register.isOverflow); + decoder.decode( + fromHex(fastAsciiStringOf('*', 3 * DecodeAsciiString.MAX_ALLOWED_LENGTH)), + decodeResult); + assertTrue(decodeResult.isOverflow); } } @WithByteBuf("00 00 80 00 00 00 00 80") - void testZeroByteStringMandatoryTwoValuesInRow(Collection buffers) { - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertFalse(decoder.isOverlong()); - assertEquals("\0\0", register.stringValue); - - decode(decoder, buffers, register); - assertTrue(decoder.isReady()); - assertFalse(decoder.isOverlong()); - assertEquals("\0\0\0\0", register.stringValue); + void testMandatoryStringTwoValuesInRow(Collection buffers) { + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("\0\0", decodeResult.stringValue); + + decode(decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals("\0\0\0\0", decodeResult.stringValue); } } } From 9745b4dfdfe55461428b1745d3a1d15143bb1c03 Mon Sep 17 00:00:00 2001 From: vdonadze Date: Wed, 5 Aug 2020 15:45:52 +0400 Subject: [PATCH 05/20] fixed ascii decode --- .../epfast/decoder/IDecodeContext.java | 2 ++ .../decoder/ascii/DecodeAsciiString.java | 3 ++- .../ascii/DecodeMandatoryAsciiString.java | 16 ++++++++++---- .../ascii/DecodeNullableAsciiString.java | 21 +++++++++++++++---- .../decimal/DecodeMandatoryDecimal.java | 6 +++--- .../decimal/DecodeNullableDecimal.java | 6 +++--- .../decoder/integer/DecodeMandatoryInt32.java | 2 +- .../decoder/integer/DecodeMandatoryInt64.java | 2 +- .../integer/DecodeMandatoryUInt32.java | 2 +- .../integer/DecodeMandatoryUInt64.java | 2 +- .../decoder/integer/DecodeNullableInt32.java | 2 +- .../decoder/integer/DecodeNullableInt64.java | 2 +- .../decoder/integer/DecodeNullableUInt32.java | 2 +- .../decoder/integer/DecodeNullableUInt64.java | 2 +- .../decoder/message/PrimitiveInstruction.java | 2 +- .../epfast/decoder/message/UnionRegister.java | 2 +- .../unicode/DecodeMandatoryByteVector.java | 2 +- .../unicode/DecodeNullableByteVector.java | 2 +- .../com/exactpro/epfast/DecoderUtils.java | 2 -- .../decoder/ascii/TestDecodeAsciiString.java | 6 +++--- 20 files changed, 54 insertions(+), 32 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java index a14444ba..41ed0528 100644 --- a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java +++ b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java @@ -20,7 +20,9 @@ import io.netty.buffer.ByteBuf; public interface IDecodeContext { + int FINISHED = 1; + int MORE_DATA_NEEDED = 0; int CLEAR_STOP_BIT_MASK = 0b01111111; diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java index 530f0fd7..5be13162 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java @@ -39,13 +39,14 @@ public abstract class DecodeAsciiString implements IDecodeContext { } public int startDecode(ByteBuf buf, UnionRegister register) { - throw new UnsupportedOperationException(); + throw new UnsupportedOperationException(); } public int continueDecode(ByteBuf buf, UnionRegister register) { throw new UnsupportedOperationException(); } + @Override public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java index ab82901d..391004fd 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java @@ -32,19 +32,27 @@ public DecodeMandatoryAsciiString(boolean checkOverlong) { public void setResult(UnionRegister register) { if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { register.isOverflow = true; - register.errorMessage = "String is longer than allowed"; + register.infoMessage = "String is longer than allowed"; } else if (zeroCount < stringBuilder.length()) { - if ((zeroCount > 0) && checkOverlong) { - register.isOverflow = true; - register.errorMessage = "String with zero preamble can't contain any value except \\0"; + if ((zeroCount > 1) && checkOverlong) { + register.isOverflow = false; + register.isOverlong = false; + register.stringValue = stringBuilder.substring(1); + } else if (zeroCount == 1) { + register.isOverflow = false; + register.isOverlong = true; + register.infoMessage = "String is overlong if first 7 bits after zero preamble are not \\0"; + register.stringValue = stringBuilder.substring(1); } else { register.isOverflow = false; + register.isOverlong = false; register.isNull = false; register.stringValue = stringBuilder.toString(); } } else { stringBuilder.setLength(zeroCount - 1); register.isOverflow = false; + register.isOverlong = false; register.isNull = false; register.stringValue = stringBuilder.toString(); } diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java index 930b5c1c..54421c36 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java @@ -32,11 +32,22 @@ public DecodeNullableAsciiString(boolean checkOverlong) { public void setResult(UnionRegister register) { if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { register.isOverflow = true; - register.errorMessage = "String is longer than allowed"; + register.infoMessage = "String is longer than allowed"; } else if (zeroCount < stringBuilder.length()) { - if ((zeroCount > 0) && checkOverlong) { - register.isOverflow = true; - register.errorMessage = "String with zero preamble can't contain any value except 0"; + if ((zeroCount > 2) && checkOverlong) { + register.isOverflow = false; + register.isOverlong = false; + register.stringValue = stringBuilder.substring(2); + } else if ((zeroCount == 1) && checkOverlong) { + register.isOverflow = false; + register.isOverlong = true; + register.infoMessage = "String is overlong if first 7 bits after zero preamble are not \\0"; + register.stringValue = stringBuilder.substring(1); + } else if ((zeroCount == 2) && checkOverlong) { + register.isOverflow = false; + register.isOverlong = true; + register.infoMessage = "String is overlong if first 7 bits after zero preamble are not \\0"; + register.stringValue = stringBuilder.substring(2); } else { register.isOverflow = false; register.isNull = false; @@ -44,6 +55,8 @@ public void setResult(UnionRegister register) { } } else if (zeroCount == 1) { register.isOverflow = false; + register.isNull = true; + register.isOverlong = false; register.stringValue = null; } else { stringBuilder.setLength(zeroCount - 2); diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java index 7406d8a6..202cf720 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java @@ -117,17 +117,17 @@ public void setRegisterValue(UnionRegister register) { inProgress = false; if (exponentOverflow) { register.isOverflow = true; - register.errorMessage = "exponent value range is int32"; + register.infoMessage = "exponent value range is int32"; } else if (mantissaOverflow) { register.isOverflow = true; - register.errorMessage = "mantissa value range is int64"; + register.infoMessage = "mantissa value range is int64"; } else if (exponent >= -63 && exponent <= 63) { register.isOverflow = false; register.isNull = false; register.decimalValue = new BigDecimal(mantissa).movePointRight(exponent); } else { register.isOverflow = true; - register.errorMessage = "exponent value allowed range is -63 ... 63"; + register.infoMessage = "exponent value allowed range is -63 ... 63"; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java index 4abdb2bf..529b2403 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java @@ -130,10 +130,10 @@ public void setRegisterValue(UnionRegister register) { inProgress = false; if (exponentOverflow) { register.isOverflow = true; - register.errorMessage = "exponent value range is int32"; + register.infoMessage = "exponent value range is int32"; } else if (mantissaOverflow) { register.isOverflow = true; - register.errorMessage = "mantissa value range is int64"; + register.infoMessage = "mantissa value range is int64"; } else if (nullValue) { register.isOverflow = false; register.decimalValue = null; @@ -143,7 +143,7 @@ public void setRegisterValue(UnionRegister register) { register.decimalValue = new BigDecimal(mantissa).movePointRight(exponent); } else { register.isOverflow = true; - register.errorMessage = "exponent value allowed range is -63 ... 63"; + register.infoMessage = "exponent value allowed range is -63 ... 63"; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java index 94091b49..cb8c5083 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java @@ -109,7 +109,7 @@ public void setRegisterValue(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; - register.errorMessage = "Int32 Overflow"; + register.infoMessage = "Int32 Overflow"; } else { register.isOverflow = false; register.isNull = false; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java index dc51f067..deab7dfd 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java @@ -109,7 +109,7 @@ public void setRegisterValue(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; - register.errorMessage = "Int64 Overflow"; + register.infoMessage = "Int64 Overflow"; } else { register.isOverflow = false; register.isNull = false; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java index 636e5f90..fccb72f0 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java @@ -79,7 +79,7 @@ public void setRegisterValue(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; - register.errorMessage = "UInt32 Overflow"; + register.infoMessage = "UInt32 Overflow"; } else { register.isOverflow = false; register.isNull = false; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java index 9dbb99ba..7f8c16d1 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java @@ -83,7 +83,7 @@ public void setRegisterValue(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; - register.errorMessage = "UInt32 Overflow"; + register.infoMessage = "UInt32 Overflow"; } else { longToBytes(value, bytes); register.isOverflow = false; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java index 71f059b1..a2d80712 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java @@ -113,7 +113,7 @@ public void setRegisterValue(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; - register.errorMessage = "Int32 Overflow"; + register.infoMessage = "Int32 Overflow"; } else { register.isOverflow = false; if (value == 0) { diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java index 3da10f37..87907751 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java @@ -113,7 +113,7 @@ public void setRegisterValue(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; - register.errorMessage = "Int64 Overflow"; + register.infoMessage = "Int64 Overflow"; } else { register.isOverflow = false; if (value == 0) { diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java index 696197e7..df559d19 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java @@ -82,7 +82,7 @@ public void setRegisterValue(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; - register.errorMessage = "UInt32 Overflow"; + register.infoMessage = "UInt32 Overflow"; } else if (value == 0) { register.isOverflow = false; register.isNull = true; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java index 40ee547e..94231922 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java @@ -86,7 +86,7 @@ public void setRegisterValue(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; - register.errorMessage = "UInt64 Overflow"; + register.infoMessage = "UInt64 Overflow"; } else if (value == 0) { register.isOverflow = false; register.isNull = true; diff --git a/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java b/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java index 97fb30de..6128b4c3 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java @@ -25,6 +25,6 @@ protected PrimitiveInstruction(T fieldDecoder) { } protected int decode(DecoderState decoderState) { - return fieldDecoder.startDecode(decoderState.inputBuffer, decoderState.register); + return fieldDecoder.decode(decoderState.inputBuffer, decoderState.register); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java b/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java index f2fa466d..29cc435a 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java @@ -46,7 +46,7 @@ public class UnionRegister { public Object applicationValue; - public String errorMessage; + public String infoMessage; public PresenceMap presenceMap; } diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java index 81556815..3125613f 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java @@ -116,7 +116,7 @@ public void setRegisterValue(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; - register.errorMessage = "length value range is uint32"; + register.infoMessage = "length value range is uint32"; } else { byte[] finalVal = new byte[value.size()]; for (int i = 0; i < value.size(); i++) { diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java index c2dfd1a1..084b952d 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java @@ -116,7 +116,7 @@ public void setRegisterValue(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; - register.errorMessage = "length value range is uint32"; + register.infoMessage = "length value range is uint32"; } else { byte[] finalVal = new byte[value.size()]; for (int i = 0; i < value.size(); i++) { diff --git a/src/test/java/com/exactpro/epfast/DecoderUtils.java b/src/test/java/com/exactpro/epfast/DecoderUtils.java index 5e6fce86..f8b3ed2a 100644 --- a/src/test/java/com/exactpro/epfast/DecoderUtils.java +++ b/src/test/java/com/exactpro/epfast/DecoderUtils.java @@ -21,8 +21,6 @@ import io.netty.buffer.ByteBuf; import java.util.Iterator; -import java.util.function.Consumer; -import java.util.function.Function; public class DecoderUtils { diff --git a/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java b/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java index 92c9835e..66a43aae 100644 --- a/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java +++ b/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java @@ -47,7 +47,7 @@ static String fastAsciiStringOf(char character, int length) { @Nested class TestOptional { - private final DecodeNullableAsciiString decoder = new DecodeNullableAsciiString(); + private final DecodeNullableAsciiString decoder = new DecodeNullableAsciiString(true); @WithByteBuf("80") void testNull(Collection buffers) { @@ -148,7 +148,7 @@ void testOptionalOverlong1(Collection buffers) { decode(decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isNull); - assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isOverlong); assertEquals("\0A", decodeResult.stringValue); } @@ -179,7 +179,7 @@ void testOptionalStringTwoValuesInRow(Collection buffers) { @Nested class TestMandatory { - private final DecodeMandatoryAsciiString decoder = new DecodeMandatoryAsciiString(); + private final DecodeMandatoryAsciiString decoder = new DecodeMandatoryAsciiString(true); @WithByteBuf("80") void testMandatoryEmptyString(Collection buffers) { From 6e47d52b23310734bfc3c53278d94a7b25453397 Mon Sep 17 00:00:00 2001 From: vdonadze Date: Wed, 5 Aug 2020 17:02:36 +0400 Subject: [PATCH 06/20] removed isReady() and isOverlong() from some decoders --- .../epfast/decoder/IDecodeContext.java | 4 - .../decoder/ascii/DecodeAsciiString.java | 8 -- .../epfast/decoder/decimal/DecodeDecimal.java | 10 +-- .../decimal/DecodeMandatoryDecimal.java | 24 ++++-- .../decimal/DecodeNullableDecimal.java | 24 ++++-- .../epfast/decoder/integer/DecodeInteger.java | 11 --- .../decoder/integer/DecodeMandatoryInt32.java | 21 +++-- .../decoder/integer/DecodeMandatoryInt64.java | 21 +++-- .../integer/DecodeMandatoryUInt32.java | 13 ++- .../integer/DecodeMandatoryUInt64.java | 8 +- .../decoder/integer/DecodeNullableInt32.java | 21 +++-- .../decoder/integer/DecodeNullableInt64.java | 16 ++-- .../decoder/integer/DecodeNullableUInt32.java | 13 ++- .../decoder/integer/DecodeNullableUInt64.java | 8 +- .../message/InstructionWithDecoder.java | 4 - .../presencemap/DecodePresenceMap.java | 29 +++---- .../decoder/unicode/DecodeByteVector.java | 1 - .../decoder/decimal/TestDecodeDecimal.java | 82 ++++++------------- .../epfast/decoder/integer/TestInt32.java | 16 ++-- .../epfast/decoder/integer/TestInt64.java | 58 ++++++------- .../epfast/decoder/integer/TestUInt32.java | 8 +- .../epfast/decoder/integer/TestUInt64.java | 31 +------ .../presencemap/TestDecodePresenceMap.java | 6 +- 23 files changed, 198 insertions(+), 239 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java index 41ed0528..bbd1574f 100644 --- a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java +++ b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java @@ -31,10 +31,6 @@ public interface IDecodeContext { int continueDecode(ByteBuf buf, UnionRegister register); - boolean isReady(); - - boolean isOverlong(); - boolean inProgress(); default int decode(ByteBuf buf, UnionRegister register) { diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java index 5be13162..f42cdbd3 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java @@ -68,14 +68,6 @@ public int decode(ByteBuf buf, UnionRegister register) { public abstract void setResult(UnionRegister unionRegister); - public boolean isReady() { - return ready; - } - - public boolean isOverlong() { - throw new UnsupportedOperationException(); - } - private int getPreambleByte(int index, ByteBuf buf) { int aByte = getByte(index, buf); if (aByte == 0) { diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java index 90b9faca..2f9df30c 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java @@ -37,6 +37,10 @@ public abstract class DecodeDecimal implements IDecodeContext { boolean mantissaOverflow; + boolean exponentOverlong; + + boolean mantissaOverlong; + protected boolean inProgress; public abstract int startDecode(ByteBuf buf, UnionRegister register); @@ -53,12 +57,6 @@ public final void reset() { public abstract void setRegisterValue(UnionRegister register); - public boolean isReady() { - return ready; - } - - public abstract boolean isOverlong(); - @Override public boolean inProgress() { return inProgress; diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java index 202cf720..6fc4aabb 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java @@ -34,6 +34,9 @@ public int startDecode(ByteBuf buf, UnionRegister register) { exponentDecoder.startDecode(buf, register); if (exponentDecoder.isReady()) { exponentReady = true; + if (register.isOverlong) { + exponentOverlong = true; + } if (register.isOverflow) { exponentOverflow = true; } else { @@ -44,6 +47,9 @@ public int startDecode(ByteBuf buf, UnionRegister register) { startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } if (register.isOverflow) { mantissaOverflow = true; } else { @@ -65,6 +71,9 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { mantissaDecoder.continueDecode(buf, register); if (mantissaDecoder.isReady()) { ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } if (register.isOverflow) { mantissaOverflow = true; } else { @@ -76,6 +85,9 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } if (register.isOverflow) { mantissaOverflow = true; } else { @@ -86,6 +98,9 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { exponentDecoder.continueDecode(buf, register); if (exponentDecoder.isReady()) { exponentReady = true; + if (register.isOverlong) { + exponentOverlong = true; + } if (register.isOverflow) { exponentOverflow = true; } else { @@ -96,6 +111,9 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } if (register.isOverflow) { mantissaOverflow = true; } else { @@ -115,6 +133,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { public void setRegisterValue(UnionRegister register) { inProgress = false; + register.isOverlong = exponentOverlong || mantissaOverlong; if (exponentOverflow) { register.isOverflow = true; register.infoMessage = "exponent value range is int32"; @@ -130,9 +149,4 @@ public void setRegisterValue(UnionRegister register) { register.infoMessage = "exponent value allowed range is -63 ... 63"; } } - - @Override - public boolean isOverlong() { - return exponentDecoder.isOverlong() || mantissaDecoder.isOverlong(); - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java index 529b2403..8178a3b4 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java @@ -36,6 +36,9 @@ public int startDecode(ByteBuf buf, UnionRegister register) { exponentDecoder.startDecode(buf, register); if (exponentDecoder.isReady()) { exponentReady = true; + if (register.isOverlong) { + exponentOverlong = true; + } if (register.isOverflow) { exponentOverflow = true; } else { @@ -46,6 +49,9 @@ public int startDecode(ByteBuf buf, UnionRegister register) { startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } if (register.isOverflow) { mantissaOverflow = true; } else { @@ -72,6 +78,9 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { mantissaDecoder.continueDecode(buf, register); if (mantissaDecoder.isReady()) { ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } if (register.isOverflow) { mantissaOverflow = true; } else { @@ -83,6 +92,9 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { mantissaDecoder.startDecode(buf, register); if (mantissaDecoder.isReady()) { ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } if (register.isOverflow) { mantissaOverflow = true; } else { @@ -93,6 +105,9 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { exponentDecoder.continueDecode(buf, register); if (exponentDecoder.isReady()) { exponentReady = true; + if (register.isOverlong) { + exponentOverlong = true; + } if (register.isOverflow) { exponentOverflow = true; } else { @@ -103,6 +118,9 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { startedMantissa = true; if (mantissaDecoder.isReady()) { ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } if (register.isOverflow) { mantissaOverflow = true; } else { @@ -128,6 +146,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { @Override public void setRegisterValue(UnionRegister register) { inProgress = false; + register.isOverlong = exponentOverlong || mantissaOverlong; if (exponentOverflow) { register.isOverflow = true; register.infoMessage = "exponent value range is int32"; @@ -146,9 +165,4 @@ public void setRegisterValue(UnionRegister register) { register.infoMessage = "exponent value allowed range is -63 ... 63"; } } - - @Override - public boolean isOverlong() { - return exponentDecoder.isOverlong() || mantissaDecoder.isOverlong(); - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java index 4af7df83..a19bd08c 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java @@ -28,28 +28,17 @@ public abstract class DecodeInteger implements IDecodeContext { protected boolean overflow; - boolean overlong; - boolean checkForSignExtension = false; public abstract int startDecode(ByteBuf buf, UnionRegister register); public abstract int continueDecode(ByteBuf buf, UnionRegister register); - public boolean isReady() { - return ready; - } - - public boolean isOverlong() { - return overlong; - } - protected boolean inProgress; protected final void reset() { ready = false; overflow = false; - overlong = false; checkForSignExtension = false; } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java index cb8c5083..24f7a08c 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java @@ -42,7 +42,7 @@ public int startDecode(ByteBuf buf, UnionRegister register) { return 1; } if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex)); //check second byte + checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -58,7 +58,7 @@ public int startDecode(ByteBuf buf, UnionRegister register) { return 1; } if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex)); //check second byte + checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -80,7 +80,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { int readLimit = buf.writerIndex(); if (value >= 0) { if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex)); //continue checking + checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking checkForSignExtension = false; } do { @@ -88,7 +88,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { } while (!ready && readerIndex < readLimit); } else { if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes + checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes checkForSignExtension = false; } do { @@ -141,11 +141,16 @@ private void accumulateNegative(int oneByte) { } } - private void checkOverlongPositive(int secondByte) { - overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlongPositive(int secondByte, UnionRegister register) { + register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } - private void checkOverlongNegative(int secondByte) { - overlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); + private void checkOverlongNegative(int secondByte, UnionRegister register) { + register.isOverlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); + } + + //TODO remove + public boolean isReady() { + return ready; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java index deab7dfd..5c2ca7af 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java @@ -42,7 +42,7 @@ public int startDecode(ByteBuf buf, UnionRegister register) { return 1; } if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex)); //check second byte + checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -58,7 +58,7 @@ public int startDecode(ByteBuf buf, UnionRegister register) { return 1; } if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex)); //check second byte + checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -80,7 +80,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { int readLimit = buf.writerIndex(); if (value >= 0) { if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex)); //continue checking + checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking checkForSignExtension = false; } do { @@ -88,7 +88,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { } while (!ready && readerIndex < readLimit); } else { if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes + checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes checkForSignExtension = false; } do { @@ -141,11 +141,16 @@ private void accumulateNegative(int oneByte) { } } - private void checkOverlongPositive(int secondByte) { - overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlongPositive(int secondByte, UnionRegister register) { + register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } - private void checkOverlongNegative(int secondByte) { - overlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); + private void checkOverlongNegative(int secondByte, UnionRegister register) { + register.isOverlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); + } + + //TODO remove + public boolean isReady() { + return ready; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java index fccb72f0..405f40f3 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java @@ -39,7 +39,7 @@ public int startDecode(ByteBuf buf, UnionRegister register) { return 1; } if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex)); //check second byte + checkOverlong(buf.getByte(readerIndex), register); //check second byte do { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -59,7 +59,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex)); //continue checking + checkOverlong(buf.getByte(readerIndex), register); //continue checking checkForSignExtension = false; } do { @@ -99,7 +99,12 @@ private void accumulate(int oneByte) { } } - private void checkOverlong(int secondByte) { - overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlong(int secondByte, UnionRegister register) { + register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + } + + //TODO remove + public boolean isReady() { + return ready; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java index 7f8c16d1..d56eaaaa 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java @@ -43,7 +43,7 @@ public int startDecode(ByteBuf buf, UnionRegister register) { return 1; } if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex)); //check second byte + checkOverlong(buf.getByte(readerIndex), register); //check second byte do { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -63,7 +63,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex)); //continue checking + checkOverlong(buf.getByte(readerIndex), register); //continue checking checkForSignExtension = false; } do { @@ -104,8 +104,8 @@ private void accumulate(int oneByte) { } } - private void checkOverlong(int secondByte) { - overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlong(int secondByte, UnionRegister register) { + register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java index a2d80712..fd8b0918 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java @@ -45,7 +45,7 @@ public int startDecode(ByteBuf buf, UnionRegister register) { return 1; } if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex)); //check second byte + checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -62,7 +62,7 @@ public int startDecode(ByteBuf buf, UnionRegister register) { return 1; } if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex)); //check second byte + checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -84,7 +84,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { int readLimit = buf.writerIndex(); if (value >= 0) { if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex)); //continue checking + checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking checkForSignExtension = false; } do { @@ -92,7 +92,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { } while (!ready && readerIndex < readLimit); } else { if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes + checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes checkForSignExtension = false; } do { @@ -151,11 +151,16 @@ private void accumulateNegative(int oneByte) { } } - private void checkOverlongPositive(int secondByte) { - overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlongPositive(int secondByte, UnionRegister register) { + register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } - private void checkOverlongNegative(int secondByte) { - overlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); + private void checkOverlongNegative(int secondByte, UnionRegister register) { + register.isOverlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); + } + + //TODO remove + public boolean isReady() { + return ready; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java index 87907751..7a403ba8 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java @@ -45,7 +45,7 @@ public int startDecode(ByteBuf buf, UnionRegister register) { return 1; } if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex)); //check second byte + checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -62,7 +62,7 @@ public int startDecode(ByteBuf buf, UnionRegister register) { return 1; } if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex)); //check second byte + checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -84,7 +84,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { int readLimit = buf.writerIndex(); if (value >= 0) { if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex)); //continue checking + checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking checkForSignExtension = false; } do { @@ -92,7 +92,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { } while (!ready && readerIndex < readLimit); } else { if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes + checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes checkForSignExtension = false; } do { @@ -151,11 +151,11 @@ private void accumulateNegative(int oneByte) { } } - private void checkOverlongPositive(int secondByte) { - overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlongPositive(int secondByte, UnionRegister register) { + register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } - private void checkOverlongNegative(int secondByte) { - overlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); + private void checkOverlongNegative(int secondByte, UnionRegister register) { + register.isOverlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java index df559d19..78c53a00 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java @@ -42,7 +42,7 @@ public int startDecode(ByteBuf buf, UnionRegister register) { return 1; } if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex)); //check second byte + checkOverlong(buf.getByte(readerIndex), register); //check second byte do { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -62,7 +62,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex)); //continue checking + checkOverlong(buf.getByte(readerIndex), register); //continue checking checkForSignExtension = false; } do { @@ -107,7 +107,12 @@ private void accumulate(int oneByte) { } } - private void checkOverlong(int secondByte) { - overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlong(int secondByte, UnionRegister register) { + register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + } + + //TODO remove + public boolean isReady() { + return ready; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java index 94231922..6875fa1a 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java @@ -46,7 +46,7 @@ public int startDecode(ByteBuf buf, UnionRegister register) { return 1; } if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex)); //check second byte + checkOverlong(buf.getByte(readerIndex), register); //check second byte do { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -66,7 +66,7 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex)); //continue checking + checkOverlong(buf.getByte(readerIndex), register); //continue checking checkForSignExtension = false; } do { @@ -116,7 +116,7 @@ private void accumulate(int oneByte) { } } - private void checkOverlong(int secondByte) { - overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlong(int secondByte, UnionRegister register) { + register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java b/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java index 223cde1a..5a6e7011 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java @@ -31,10 +31,6 @@ protected InstructionWithDecoder(T fieldDecoder) { protected abstract int decode(DecoderState decoderState) throws OverflowException; - public boolean isReady() { - return fieldDecoder.isReady(); - } - @Override public int executeOn(DecoderState decoderState) throws OverflowException { if (!decoderState.inputBuffer.isReadable()) { diff --git a/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java b/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java index 1e3131d2..6a258a07 100644 --- a/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java +++ b/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java @@ -32,21 +32,16 @@ public class DecodePresenceMap implements IDecodeContext { private boolean ready; - protected boolean inProgress; - public int startDecode(ByteBuf buf, UnionRegister register) { - reset(); - inProgress = true; - continueDecode(buf, register); - if (ready) { - setRegisterValue(register); - return 1; - } else { - return 0; - } + throw new UnsupportedOperationException(); } public int continueDecode(ByteBuf buf, UnionRegister register) { + throw new UnsupportedOperationException(); + } + + @Override + public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); while ((readerIndex < readLimit) && !ready) { @@ -55,15 +50,15 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { buf.readerIndex(readerIndex); if (ready) { setRegisterValue(register); - return 1; + reset(); + return FINISHED; } else { - return 0; + return MORE_DATA_NEEDED; } } public void setRegisterValue(UnionRegister register) { - //TODO add overlong checks for presence map - inProgress = false; + register.isOverlong = setIndex > lastNonZeroIndex; register.presenceMap = new PresenceMap((BitSet) value.clone()); } @@ -72,7 +67,7 @@ public boolean isReady() { } public boolean isOverlong() { - return setIndex > lastNonZeroIndex; + throw new UnsupportedOperationException(); } private void accumulateValue(int oneByte) { @@ -97,7 +92,7 @@ public final void reset() { @Override public boolean inProgress() { - return inProgress; + throw new UnsupportedOperationException(); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java index 61a4a7b7..0cffd718 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java @@ -51,7 +51,6 @@ public boolean isOverflow() { return overflow; } - @Override public boolean isOverlong() { return false; } diff --git a/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java b/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java index 3d7a6ec9..6277c3fa 100644 --- a/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java +++ b/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java @@ -37,88 +37,77 @@ class TestDecodeDecimal { @WithByteBuf("80") void testNull(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); - assertFalse(nullableDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertNull(register.decimalValue); } @WithByteBuf("83 39 45 a3") void testNullablePositive1(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); - assertFalse(nullableDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("82 04 3f 34 de") void testNullablePositive(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); - assertFalse(nullableDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("82 39 45 a3") void testMandatoryPositive(Collection buffers) { decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(mandatoryDecimalDecoder.isReady()); - assertFalse(mandatoryDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("81 04 3f 34 de") void testMandatoryPositive2(Collection buffers) { decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(mandatoryDecimalDecoder.isReady()); - assertFalse(mandatoryDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("fe 39 45 a3") void testMandatoryPositive3(Collection buffers) { decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(mandatoryDecimalDecoder.isReady()); - assertFalse(mandatoryDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigDecimal("9427.55"), register.decimalValue); } @WithByteBuf("fe 39 45 a3") void testNullablePositive3(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); - assertFalse(nullableDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigDecimal("9427.55"), register.decimalValue); } @WithByteBuf("fe 46 3a dd") void testNullableNegative(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); - assertFalse(nullableDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigDecimal("-9427.55"), register.decimalValue); } @WithByteBuf("fd 7f 3f ff") void testNullableNegativeSignExtension(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); - assertFalse(nullableDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigDecimal("-8.193"), register.decimalValue); } @WithByteBuf("39 45 a4 7f 3f ff") void testExponentIOException(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); - assertFalse(nullableDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertTrue(register.isOverflow); } @WithByteBuf("82 04 3f 34 de") void testNullablePositiveGetValueTwice(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); - assertFalse(nullableDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigDecimal("94275500"), register.decimalValue); assertEquals(new BigDecimal("94275500"), register.decimalValue); } @@ -126,8 +115,7 @@ void testNullablePositiveGetValueTwice(Collection buffers) { @WithByteBuf("82 39 45 a3") void testMandatoryPositiveGetValueTwice(Collection buffers) { decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(mandatoryDecimalDecoder.isReady()); - assertFalse(mandatoryDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigDecimal("94275500"), register.decimalValue); assertEquals(new BigDecimal("94275500"), register.decimalValue); } @@ -135,146 +123,124 @@ void testMandatoryPositiveGetValueTwice(Collection buffers) { @WithByteBuf("83 39 45 a3 82 04 3f 34 de") void testNullablePositiveTwoValuesInRow(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); - assertFalse(nullableDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigDecimal("94275500"), register.decimalValue); - decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); - assertFalse(nullableDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("82 39 45 a3 81 04 3f 34 de") void testMandatoryPositiveTwoValuesInRow(Collection buffers) { decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(mandatoryDecimalDecoder.isReady()); - assertFalse(mandatoryDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigDecimal("94275500"), register.decimalValue); - decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(mandatoryDecimalDecoder.isReady()); - assertFalse(mandatoryDecimalDecoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("08 00 00 00 81 39 45 a3") void testNullableExponentOverflow1(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("08 00 00 00 80 39 45 a3") void testMandatoryExponentOverflow1(Collection buffers) { decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(mandatoryDecimalDecoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("08 00 00 00 00 81 39 45 a3") void testNullableExponentOverflow2(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("07 7f 00 7f 7f 7f ff 39 45 a3") void testMandatoryExponentOverflow2(Collection buffers) { decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(mandatoryDecimalDecoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("86 01 00 00 00 00 00 00 00 00 80") void testNullableMantissaOverflow1(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("86 01 00 00 00 00 00 00 00 00 80") void testMandatoryMantissaOverflow1(Collection buffers) { decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(mandatoryDecimalDecoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("86 00 7f 00 7f 7f 7f 7f 7f 7f 7f ff") void testNullableMantissaOverflow2(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("86 00 7f 00 7f 7f 7f 7f 7f 7f 7f ff") void testMandatoryMantissaOverflow2(Collection buffers) { decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(mandatoryDecimalDecoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("00 83 39 45 a3") void testNullableExponentOverlong(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); - assertTrue(nullableDecimalDecoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("7f fe 46 3a dd") void testNullableNegativeExponentOverlong(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); - assertTrue(nullableDecimalDecoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(new BigDecimal("-9427.55"), register.decimalValue); } @WithByteBuf("00 82 39 45 a3") void testMandatoryExponentOverlong(Collection buffers) { decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(mandatoryDecimalDecoder.isReady()); - assertTrue(mandatoryDecimalDecoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("7f fe 46 3a dd") void testMandatoryNegativeExponentOverlong(Collection buffers) { decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(mandatoryDecimalDecoder.isReady()); - assertTrue(mandatoryDecimalDecoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(new BigDecimal("-9427.55"), register.decimalValue); } @WithByteBuf("fe 7f 46 3a dd") void testNullableNegativeMantissaOverlong(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); - assertTrue(nullableDecimalDecoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(new BigDecimal("-9427.55"), register.decimalValue); } @WithByteBuf("83 00 39 45 a3") void testNullableMantissaOverlong(Collection buffers) { decode(nullableDecimalDecoder, buffers, register); - assertTrue(nullableDecimalDecoder.isReady()); - assertTrue(nullableDecimalDecoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("82 00 39 45 a3") void testMandatoryMantissaOverlong(Collection buffers) { decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(mandatoryDecimalDecoder.isReady()); - assertTrue(mandatoryDecimalDecoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(new BigDecimal("94275500"), register.decimalValue); } @WithByteBuf("fe 7f 46 3a dd") void testMandatoryNegativeMantissaOverlong(Collection buffers) { decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(mandatoryDecimalDecoder.isReady()); - assertTrue(mandatoryDecimalDecoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(new BigDecimal("-9427.55"), register.decimalValue); } } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java index 61f933aa..a41d1855 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java @@ -257,7 +257,7 @@ void optionalPositiveTwoValuesInRow(Collection buffers) { void mandatoryOverlong(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertTrue(mandatoryInt32Decoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(942756, register.int32Value); } @@ -265,7 +265,7 @@ void mandatoryOverlong(Collection buffers) { void mandatoryNotOverlong(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertFalse(mandatoryInt32Decoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(8193, register.int32Value); } @@ -273,7 +273,7 @@ void mandatoryNotOverlong(Collection buffers) { void mandatoryOverlongNegative(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertTrue(mandatoryInt32Decoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(-7942755, register.int32Value); } @@ -281,7 +281,7 @@ void mandatoryOverlongNegative(Collection buffers) { void mandatoryNotOverlongNegative(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); assertTrue(mandatoryInt32Decoder.isReady()); - assertFalse(mandatoryInt32Decoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(-8193, register.int32Value); } @@ -289,7 +289,7 @@ void mandatoryNotOverlongNegative(Collection buffers) { void nullableOverlong(Collection buffers) { decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertTrue(nullableInt32Decoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(942755, register.int32Value); } @@ -297,7 +297,7 @@ void nullableOverlong(Collection buffers) { void nullableNotOverlong(Collection buffers) { decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertFalse(nullableInt32Decoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(8192, register.int32Value); } @@ -305,7 +305,7 @@ void nullableNotOverlong(Collection buffers) { void nullableOverlongNegative(Collection buffers) { decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertTrue(nullableInt32Decoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(-7942755, register.int32Value); } @@ -313,7 +313,7 @@ void nullableOverlongNegative(Collection buffers) { void nullableNotOverlongNegative(Collection buffers) { decode(nullableInt32Decoder, buffers, register); assertTrue(nullableInt32Decoder.isReady()); - assertFalse(nullableInt32Decoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(-8193, register.int32Value); } } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java index caa275c9..e1d2d021 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java @@ -36,14 +36,14 @@ class TestInt64 { @WithByteBuf("80") void testNull(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertTrue(register.isNull); } @WithByteBuf("81") void optionalZero(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertEquals(0, register.int64Value); } @@ -57,7 +57,7 @@ void mandatoryZero(Collection buffers) { @WithByteBuf("01 00 00 00 00 00 00 00 00 80") void testMaxNullable(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertEquals(Long.MAX_VALUE, register.int64Value); } @@ -71,7 +71,7 @@ void testMaxMandatory(Collection buffers) { @WithByteBuf("7f 00 00 00 00 00 00 00 00 80") void testMinNullable(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertEquals(Long.MIN_VALUE, register.int64Value); } @@ -85,14 +85,14 @@ void testMinMandatory(Collection buffers) { @WithByteBuf("01 00 00 00 00 00 00 00 00 81") void testMaxOverflowNullable1(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertTrue(register.isOverflow); } @WithByteBuf("01 00 00 00 00 00 00 00 00 00 80") void testMaxOverflowNullable2(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertTrue(register.isOverflow); } @@ -113,14 +113,14 @@ void testMaxOverflowMandatory2(Collection buffers) { @WithByteBuf("77 7f 7f 7f 7f 7f 7f 7f 7f ff") void testMinOverflowNullable1(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertTrue(register.isOverflow); } @WithByteBuf("7f 00 00 00 00 00 00 00 00 00 80") void testMinOverflowNullable2(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertTrue(register.isOverflow); } @@ -141,7 +141,7 @@ void testMinOverflowMandatory2(Collection buffers) { @WithByteBuf("39 45 a4") void optionalPositive(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertEquals(942755, register.int64Value); } @@ -155,7 +155,7 @@ void mandatoryPositive(Collection buffers) { @WithByteBuf("46 3a dd") void optionalNegative(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertEquals(-942755, register.int64Value); } @@ -169,7 +169,7 @@ void mandatoryNegative(Collection buffers) { @WithByteBuf("ff") void optionalMinusOne(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertEquals(-1, register.int64Value); } @@ -183,7 +183,7 @@ void mandatoryMinusOne(Collection buffers) { @WithByteBuf("00 00 40 82") void optionalSignExtensionPositive(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertEquals(8193, register.int64Value); } @@ -197,7 +197,7 @@ void mandatorySignExtensionPositive(Collection buffers) { @WithByteBuf("7f 3f ff") void optionalSignExtensionNegative(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertEquals(-8193, register.int64Value); } @@ -233,22 +233,22 @@ void mandatoryPositiveTwoValuesInRow(Collection buffers) { @WithByteBuf("7f 3f ff 7f 3f ff") void optionalNegativeTwoValuesInRow(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertEquals(-8193, register.int64Value); decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertEquals(-8193, register.int64Value); } @WithByteBuf("00 00 40 82 00 00 40 82") void optionalPositiveTwoValuesInRow(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertEquals(8193, register.int64Value); decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); + assertEquals(8193, register.int64Value); } @@ -256,7 +256,7 @@ void optionalPositiveTwoValuesInRow(Collection buffers) { void mandatoryOverlong(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertTrue(mandatoryInt64Decoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(942756, register.int64Value); } @@ -264,7 +264,7 @@ void mandatoryOverlong(Collection buffers) { void mandatoryNotOverlong(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertFalse(mandatoryInt64Decoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(8193, register.int64Value); } @@ -272,7 +272,7 @@ void mandatoryNotOverlong(Collection buffers) { void mandatoryOverlongNegative(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertTrue(mandatoryInt64Decoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(-7942755, register.int64Value); } @@ -280,39 +280,39 @@ void mandatoryOverlongNegative(Collection buffers) { void mandatoryNotOverlongNegative(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); assertTrue(mandatoryInt64Decoder.isReady()); - assertFalse(mandatoryInt64Decoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(-8193, register.int64Value); } @WithByteBuf("00 39 45 a4") void nullableOverlong(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); - assertTrue(nullableInt64Decoder.isOverlong()); + + assertTrue(register.isOverlong); assertEquals(942755, register.int64Value); } @WithByteBuf("00 40 81") void nullableNotOverlong(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); - assertFalse(nullableInt64Decoder.isOverlong()); + + assertFalse(register.isOverlong); assertEquals(8192, register.int64Value); } @WithByteBuf("7f 7c 1b 1b 9d") void nullableOverlongNegative(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); - assertTrue(nullableInt64Decoder.isOverlong()); + + assertTrue(register.isOverlong); assertEquals(-7942755, register.int64Value); } @WithByteBuf("7f 3f ff") void nullableNotOverlongNegative(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(nullableInt64Decoder.isReady()); - assertFalse(nullableInt64Decoder.isOverlong()); + + assertFalse(register.isOverlong); assertEquals(-8193, register.int64Value); } } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java index 7e851086..56685b47 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java @@ -159,7 +159,7 @@ void mandatorySimpleNumbersTwoValuesInRow(Collection buffers) { void mandatoryOverlong(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); assertTrue(mandatoryUInt32Decoder.isReady()); - assertTrue(mandatoryUInt32Decoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(942756, register.uInt32Value); } @@ -167,7 +167,7 @@ void mandatoryOverlong(Collection buffers) { void mandatoryNotOverlong(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); assertTrue(mandatoryUInt32Decoder.isReady()); - assertFalse(mandatoryUInt32Decoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(8193, register.uInt32Value); } @@ -175,7 +175,7 @@ void mandatoryNotOverlong(Collection buffers) { void nullableOverlong(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); assertTrue(nullableUInt32Decoder.isReady()); - assertTrue(nullableUInt32Decoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(942755, register.uInt32Value); } @@ -183,7 +183,7 @@ void nullableOverlong(Collection buffers) { void nullableNotOverlong(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); assertTrue(nullableUInt32Decoder.isReady()); - assertFalse(nullableUInt32Decoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(8192, register.uInt32Value); } } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java index 171298a9..e66a21d0 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java @@ -37,98 +37,84 @@ class TestUInt64 { @WithByteBuf("80") void testNull(Collection buffers) { decode(nullableUInt64Decoder, buffers, register); - assertTrue(nullableUInt64Decoder.isReady()); assertTrue(register.isNull); } @WithByteBuf("81") void optionalZero(Collection buffers) { decode(nullableUInt64Decoder, buffers, register); - assertTrue(nullableUInt64Decoder.isReady()); assertEquals(new BigInteger("0"), register.unsignedInt64Value); } @WithByteBuf("80") void mandatoryZero(Collection buffers) { decode(mandatoryUInt64Decoder, buffers, register); - assertTrue(mandatoryUInt64Decoder.isReady()); assertEquals(new BigInteger("0"), register.unsignedInt64Value); } @WithByteBuf("02 00 00 00 00 00 00 00 00 80") void testMaxNullable(Collection buffers) { decode(nullableUInt64Decoder, buffers, register); - assertTrue(nullableUInt64Decoder.isReady()); assertEquals(new BigInteger("18446744073709551615"), register.unsignedInt64Value); } @WithByteBuf("01 7f 7f 7f 7f 7f 7f 7f 7f ff") void testMaxMandatory(Collection buffers) { decode(mandatoryUInt64Decoder, buffers, register); - assertTrue(mandatoryUInt64Decoder.isReady()); assertEquals(new BigInteger("18446744073709551615"), register.unsignedInt64Value); } @WithByteBuf("02 00 00 00 00 00 00 00 00 81") void testMaxOverflowNullable1(Collection buffers) { decode(nullableUInt64Decoder, buffers, register); - assertTrue(nullableUInt64Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("02 00 00 00 00 00 00 00 00 00 80") void testMaxOverflowNullable2(Collection buffers) { decode(nullableUInt64Decoder, buffers, register); - assertTrue(nullableUInt64Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("02 00 00 00 00 00 00 00 00 80") void testMaxOverflowMandatory1(Collection buffers) { decode(mandatoryUInt64Decoder, buffers, register); - assertTrue(mandatoryUInt64Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("01 7f 7f 7f 7f 00 7f 7f 7f 7f ff") void testMaxOverflowMandatory2(Collection buffers) { decode(mandatoryUInt64Decoder, buffers, register); - assertTrue(mandatoryUInt64Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("39 45 a4") void optionalSimpleNumber1(Collection buffers) { decode(nullableUInt64Decoder, buffers, register); - assertTrue(nullableUInt64Decoder.isReady()); assertEquals(new BigInteger("942755"), register.unsignedInt64Value); } @WithByteBuf("01 7f 7f 7f 7f 7f 7f 7f 7f ff") void optionalSimpleNumber2(Collection buffers) { decode(nullableUInt64Decoder, buffers, register); - assertTrue(nullableUInt64Decoder.isReady()); assertEquals(new BigInteger("18446744073709551614"), register.unsignedInt64Value); } @WithByteBuf("39 45 a3") void mandatorySimpleNumber1(Collection buffers) { decode(mandatoryUInt64Decoder, buffers, register); - assertTrue(mandatoryUInt64Decoder.isReady()); assertEquals(new BigInteger("942755"), register.unsignedInt64Value); } @WithByteBuf("01 10 78 20 76 62 2a 62 51 cf") void mandatorySimpleNumber2(Collection buffers) { decode(mandatoryUInt64Decoder, buffers, register); - assertTrue(mandatoryUInt64Decoder.isReady()); assertEquals(new BigInteger("10443992354206034127"), register.unsignedInt64Value); } @WithByteBuf("39 45 a4") void optionalSimpleNumber1GetValueTwice(Collection buffers) { decode(nullableUInt64Decoder, buffers, register); - assertTrue(nullableUInt64Decoder.isReady()); assertEquals(new BigInteger("942755"), register.unsignedInt64Value); assertEquals(new BigInteger("942755"), register.unsignedInt64Value); } @@ -136,7 +122,6 @@ void optionalSimpleNumber1GetValueTwice(Collection buffers) { @WithByteBuf("39 45 a3") void mandatorySimpleNumber1GetValueTwice(Collection buffers) { decode(mandatoryUInt64Decoder, buffers, register); - assertTrue(mandatoryUInt64Decoder.isReady()); assertEquals(new BigInteger("942755"), register.unsignedInt64Value); assertEquals(new BigInteger("942755"), register.unsignedInt64Value); } @@ -144,54 +129,46 @@ void mandatorySimpleNumber1GetValueTwice(Collection buffers) { @WithByteBuf("39 45 a4 01 7f 7f 7f 7f 7f 7f 7f 7f ff") void optionalSimpleNumbersTwoValuesInRow(Collection buffers) { decode(nullableUInt64Decoder, buffers, register); - assertTrue(nullableUInt64Decoder.isReady()); assertEquals(new BigInteger("942755"), register.unsignedInt64Value); decode(nullableUInt64Decoder, buffers, register); - assertTrue(nullableUInt64Decoder.isReady()); assertEquals(new BigInteger("18446744073709551614"), register.unsignedInt64Value); } @WithByteBuf("39 45 a3 01 10 78 20 76 62 2a 62 51 cf") void mandatorySimpleNumbersTwoValuesInRow(Collection buffers) { decode(mandatoryUInt64Decoder, buffers, register); - assertTrue(mandatoryUInt64Decoder.isReady()); assertEquals(new BigInteger("942755"), register.unsignedInt64Value); decode(mandatoryUInt64Decoder, buffers, register); - assertTrue(mandatoryUInt64Decoder.isReady()); assertEquals(new BigInteger("10443992354206034127"), register.unsignedInt64Value); } @WithByteBuf("00 39 45 a4") void mandatoryOverlong(Collection buffers) { decode(mandatoryUInt64Decoder, buffers, register); - assertTrue(mandatoryUInt64Decoder.isReady()); - assertTrue(mandatoryUInt64Decoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(new BigInteger("942756"), register.unsignedInt64Value); } @WithByteBuf("00 40 81") void mandatoryNotOverlong(Collection buffers) { decode(mandatoryUInt64Decoder, buffers, register); - assertTrue(mandatoryUInt64Decoder.isReady()); - assertFalse(mandatoryUInt64Decoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigInteger("8193"), register.unsignedInt64Value); } @WithByteBuf("00 39 45 a4") void nullableOverlong(Collection buffers) { decode(nullableUInt64Decoder, buffers, register); - assertTrue(nullableUInt64Decoder.isReady()); - assertTrue(nullableUInt64Decoder.isOverlong()); + assertTrue(register.isOverlong); assertEquals(new BigInteger("942755"), register.unsignedInt64Value); } @WithByteBuf("00 40 81") void nullableNotOverlong(Collection buffers) { decode(nullableUInt64Decoder, buffers, register); - assertTrue(nullableUInt64Decoder.isReady()); - assertFalse(nullableUInt64Decoder.isOverlong()); + assertFalse(register.isOverlong); assertEquals(new BigInteger("8192"), register.unsignedInt64Value); } } diff --git a/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java b/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java index f54fceef..d8877d41 100644 --- a/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java +++ b/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java @@ -47,7 +47,6 @@ void testSingleByte(Collection buffers) { @WithByteBuf("15 15 00 00 00 80") void testOverlong(Collection buffers) { decode(presenceMapDecoder, buffers, register); - assertTrue(presenceMapDecoder.isReady()); PresenceMap presenceMap = register.presenceMap; assertTrue(presenceMap.getValue(0)); assertFalse(presenceMap.getValue(1)); @@ -56,13 +55,12 @@ void testOverlong(Collection buffers) { assertTrue(presenceMap.getValue(4)); assertFalse(presenceMap.getValue(5)); assertFalse(presenceMap.getValue(6)); - assertTrue(presenceMapDecoder.isOverlong()); + assertTrue(register.isOverlong); } @WithByteBuf("15 15 00 00 00 82") void testTruncateWhenNotOverlong(Collection buffers) { decode(presenceMapDecoder, buffers, register); - assertTrue(presenceMapDecoder.isReady()); PresenceMap presenceMap = register.presenceMap; assertTrue(presenceMap.getValue(0)); assertFalse(presenceMap.getValue(1)); @@ -71,6 +69,6 @@ void testTruncateWhenNotOverlong(Collection buffers) { assertTrue(presenceMap.getValue(4)); assertFalse(presenceMap.getValue(5)); assertFalse(presenceMap.getValue(6)); - assertFalse(presenceMapDecoder.isOverlong()); + assertFalse(register.isOverlong); } } From a0a995db5b977c41214b9a18a0a2223b1d0a20ac Mon Sep 17 00:00:00 2001 From: vdonadze Date: Thu, 6 Aug 2020 02:14:32 +0400 Subject: [PATCH 07/20] combining decode methods first step --- .../integer/DecodeMandatoryUInt32.java | 70 ++++++++--------- .../decoder/integer/DecodeNullableUInt32.java | 68 ++++++++-------- .../unicode/DecodeMandatoryByteVector.java | 46 +++++------ .../unicode/DecodeNullableByteVector.java | 50 ++++++------ .../epfast/decoder/integer/TestUInt32.java | 78 +++++++++---------- .../decoder/unicode/TestDecodeByteVector.java | 30 +++---- 6 files changed, 167 insertions(+), 175 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java index 405f40f3..92152280 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java @@ -26,51 +26,51 @@ public final class DecodeMandatoryUInt32 extends DecodeInteger { private int value; public int startDecode(ByteBuf buf, UnionRegister register) { - reset(); - value = 0; - inProgress = true; - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - int oneByte = buf.getByte(readerIndex++); - accumulate(oneByte); - if (oneByte < 0) { - setRegisterValue(register); - buf.readerIndex(readerIndex); - return 1; - } - if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex), register); //check second byte - do { - accumulate(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; - } - buf.readerIndex(readerIndex); - if (ready) { - setRegisterValue(register); - return 1; - } else { - return 0; - } + throw new UnsupportedOperationException(); } public int continueDecode(ByteBuf buf, UnionRegister register) { + throw new UnsupportedOperationException(); + } + + @Override + public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); - if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex), register); //continue checking - checkForSignExtension = false; + if (!inProgress) { + value = 0; + inProgress = true; + int oneByte = buf.getByte(readerIndex++); + accumulate(oneByte); + if (oneByte < 0) { + setRegisterValue(register); + buf.readerIndex(readerIndex); + return FINISHED; + } + if (readerIndex < readLimit) { + checkOverlong(buf.getByte(readerIndex), register); //check second byte + do { + accumulate(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } else { + checkForSignExtension = true; + } + } else { + if (checkForSignExtension) { + checkOverlong(buf.getByte(readerIndex), register); //continue checking + checkForSignExtension = false; + } + do { + accumulate(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); } - do { - accumulate(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); buf.readerIndex(readerIndex); if (ready) { setRegisterValue(register); - return 1; + reset(); + return FINISHED; } else { - return 0; + return MORE_DATA_NEEDED; } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java index 78c53a00..cb06d49b 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java @@ -28,49 +28,49 @@ public final class DecodeNullableUInt32 extends DecodeInteger { private int value; public int startDecode(ByteBuf buf, UnionRegister register) { - reset(); - value = 0; - isUInt32Limit = false; - inProgress = true; - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - int oneByte = buf.getByte(readerIndex++); - accumulate(oneByte); - if (oneByte < 0) { - setRegisterValue(register); - buf.readerIndex(readerIndex); - return 1; - } - if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex), register); //check second byte - do { - accumulate(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; - } - buf.readerIndex(readerIndex); - if (ready) { - setRegisterValue(register); - return 1; - } else { - return 0; - } + throw new UnsupportedOperationException(); } public int continueDecode(ByteBuf buf, UnionRegister register) { + throw new UnsupportedOperationException(); + } + + @Override + public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); - if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex), register); //continue checking - checkForSignExtension = false; + if (!inProgress) { + value = 0; + isUInt32Limit = false; + inProgress = true; + int oneByte = buf.getByte(readerIndex++); + accumulate(oneByte); + if (oneByte < 0) { + setRegisterValue(register); + buf.readerIndex(readerIndex); + return 1; + } + if (readerIndex < readLimit) { + checkOverlong(buf.getByte(readerIndex), register); //check second byte + do { + accumulate(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } else { + checkForSignExtension = true; + } + } else { + if (checkForSignExtension) { + checkOverlong(buf.getByte(readerIndex), register); //continue checking + checkForSignExtension = false; + } + do { + accumulate(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); } - do { - accumulate(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); buf.readerIndex(readerIndex); if (ready) { setRegisterValue(register); + reset(); return 1; } else { return 0; diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java index 3125613f..245467a1 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java @@ -29,8 +29,7 @@ public final class DecodeMandatoryByteVector extends DecodeByteVector { public int startDecode(ByteBuf buf, UnionRegister register) { reset(); inProgress = true; - lengthDecoder.startDecode(buf, register); - if (lengthDecoder.isReady()) { + if (lengthDecoder.decode(buf, register) == FINISHED) { lengthReady = true; if (register.isOverflow) { overflow = true; @@ -76,31 +75,28 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { } } buf.readerIndex(readerIndex); - } else { - lengthDecoder.continueDecode(buf, register); - if (lengthDecoder.isReady()) { - lengthReady = true; - if (register.isOverflow) { - overflow = true; - } else { - messageLength = register.uInt32Value; - } - if (messageLength > 0) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - while ((readerIndex < readLimit) && !ready) { - if (counter < messageLength) { - value.add(buf.getByte(readerIndex++)); - counter++; - } - if (counter == messageLength) { - ready = true; - } + } else if (lengthDecoder.decode(buf, register) == FINISHED) { + lengthReady = true; + if (register.isOverflow) { + overflow = true; + } else { + messageLength = register.uInt32Value; + } + if (messageLength > 0) { + int readerIndex = buf.readerIndex(); + int readLimit = buf.writerIndex(); + while ((readerIndex < readLimit) && !ready) { + if (counter < messageLength) { + value.add(buf.getByte(readerIndex++)); + counter++; + } + if (counter == messageLength) { + ready = true; } - buf.readerIndex(readerIndex); - } else { - ready = true; } + buf.readerIndex(readerIndex); + } else { + ready = true; } } if (ready) { diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java index 084b952d..98ac1417 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java @@ -29,8 +29,7 @@ public final class DecodeNullableByteVector extends DecodeByteVector { public int startDecode(ByteBuf buf, UnionRegister register) { reset(); inProgress = true; - lengthDecoder.startDecode(buf, register); - if (lengthDecoder.isReady()) { + if (lengthDecoder.decode(buf, register) == FINISHED) { lengthReady = true; if (register.isOverflow) { overflow = true; @@ -56,9 +55,9 @@ public int startDecode(ByteBuf buf, UnionRegister register) { } if (ready) { setRegisterValue(register); - return 1; + return FINISHED; } else { - return 0; + return MORE_DATA_NEEDED; } } @@ -76,31 +75,28 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { } } buf.readerIndex(readerIndex); - } else { - lengthDecoder.continueDecode(buf, register); - if (lengthDecoder.isReady()) { - lengthReady = true; - if (register.isOverflow) { - overflow = true; - } else { - messageLength = register.uInt32Value; - } - if (!register.isNull && messageLength > 0) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - while ((readerIndex < readLimit) && !ready) { - if (counter < messageLength) { - value.add(buf.getByte(readerIndex++)); - counter++; - } - if (counter == messageLength) { - ready = true; - } + } else if (lengthDecoder.decode(buf, register) == FINISHED) { + lengthReady = true; + if (register.isOverflow) { + overflow = true; + } else { + messageLength = register.uInt32Value; + } + if (!register.isNull && messageLength > 0) { + int readerIndex = buf.readerIndex(); + int readLimit = buf.writerIndex(); + while ((readerIndex < readLimit) && !ready) { + if (counter < messageLength) { + value.add(buf.getByte(readerIndex++)); + counter++; + } + if (counter == messageLength) { + ready = true; } - buf.readerIndex(readerIndex); - } else { - ready = true; } + buf.readerIndex(readerIndex); + } else { + ready = true; } } if (ready) { diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java index 56685b47..3b409ac5 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java @@ -30,159 +30,159 @@ class TestUInt32 { private DecodeNullableUInt32 nullableUInt32Decoder = new DecodeNullableUInt32(); private DecodeMandatoryUInt32 mandatoryUInt32Decoder = new DecodeMandatoryUInt32(); - + private UnionRegister register = new UnionRegister(); @WithByteBuf("80") - void testNull(Collection buffers) { + void testNull(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(nullableUInt32Decoder.isReady()); + assertTrue(register.isNull); } @WithByteBuf("81") - void optionalZero(Collection buffers) { + void optionalZero(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(nullableUInt32Decoder.isReady()); + assertEquals(0, register.uInt32Value); } @WithByteBuf("80") - void mandatoryZero(Collection buffers) { + void mandatoryZero(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(mandatoryUInt32Decoder.isReady()); + assertEquals(0, register.uInt32Value); } @WithByteBuf("10 00 00 00 80") - void testMaxNullable(Collection buffers) { + void testMaxNullable(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(nullableUInt32Decoder.isReady()); + assertEquals(4294967295L, register.uInt32Value); } @WithByteBuf("0f 7f 7f 7f ff") - void testMaxMandatory(Collection buffers) { + void testMaxMandatory(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(mandatoryUInt32Decoder.isReady()); + assertEquals(4294967295L, register.uInt32Value); } @WithByteBuf("10 00 00 00 81") void testMaxOverflowNullable1(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(nullableUInt32Decoder.isReady()); + assertTrue(register.isOverflow); } @WithByteBuf("10 00 00 00 00 00 80") void testMaxOverflowNullable2(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(nullableUInt32Decoder.isReady()); + assertTrue(register.isOverflow); } @WithByteBuf("10 00 00 00 80") void testMaxOverflowMandatory1(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(mandatoryUInt32Decoder.isReady()); + assertTrue(register.isOverflow); } @WithByteBuf("0f 7f 7f 7f 7f 00 ff") void testMaxOverflowMandatory2(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(mandatoryUInt32Decoder.isReady()); + assertTrue(register.isOverflow); } @WithByteBuf("39 45 a4") - void optionalSimpleNumber(Collection buffers) { + void optionalSimpleNumber(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(nullableUInt32Decoder.isReady()); + assertEquals(942755, register.uInt32Value); } @WithByteBuf("0f 7f 7f 7f ff") - void optionalSimpleNumber2(Collection buffers) { + void optionalSimpleNumber2(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(nullableUInt32Decoder.isReady()); + assertEquals(4294967294L, register.uInt32Value); } @WithByteBuf("39 45 a3") - void mandatorySimpleNumber(Collection buffers) { + void mandatorySimpleNumber(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(mandatoryUInt32Decoder.isReady()); + assertEquals(942755, register.uInt32Value); } @WithByteBuf("39 45 a4") - void optionalSimpleNumberGetValueTwice(Collection buffers) { + void optionalSimpleNumberGetValueTwice(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(nullableUInt32Decoder.isReady()); + assertEquals(942755, register.uInt32Value); assertEquals(942755, register.uInt32Value); } @WithByteBuf("39 45 a3") - void mandatorySimpleNumberGetValueTwice(Collection buffers) { + void mandatorySimpleNumberGetValueTwice(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(mandatoryUInt32Decoder.isReady()); + assertEquals(942755, register.uInt32Value); assertEquals(942755, register.uInt32Value); } @WithByteBuf("39 45 a4 0f 7f 7f 7f ff") - void optionalSimpleNumbersTwoValuesInRow(Collection buffers) { + void optionalSimpleNumbersTwoValuesInRow(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(nullableUInt32Decoder.isReady()); + assertEquals(942755, register.uInt32Value); decode(nullableUInt32Decoder, buffers, register); - assertTrue(nullableUInt32Decoder.isReady()); + assertEquals(4294967294L, register.uInt32Value); } @WithByteBuf("39 45 a3 39 45 a3") - void mandatorySimpleNumbersTwoValuesInRow(Collection buffers) { + void mandatorySimpleNumbersTwoValuesInRow(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(mandatoryUInt32Decoder.isReady()); + assertEquals(942755, register.uInt32Value); decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(mandatoryUInt32Decoder.isReady()); + assertEquals(942755, register.uInt32Value); } @WithByteBuf("00 39 45 a4") - void mandatoryOverlong(Collection buffers) { + void mandatoryOverlong(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(mandatoryUInt32Decoder.isReady()); + assertTrue(register.isOverlong); assertEquals(942756, register.uInt32Value); } @WithByteBuf("00 40 81") - void mandatoryNotOverlong(Collection buffers) { + void mandatoryNotOverlong(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(mandatoryUInt32Decoder.isReady()); + assertFalse(register.isOverlong); assertEquals(8193, register.uInt32Value); } @WithByteBuf("00 39 45 a4") - void nullableOverlong(Collection buffers) { + void nullableOverlong(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(nullableUInt32Decoder.isReady()); + assertTrue(register.isOverlong); assertEquals(942755, register.uInt32Value); } @WithByteBuf("00 40 81") - void nullableNotOverlong(Collection buffers) { + void nullableNotOverlong(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(nullableUInt32Decoder.isReady()); + assertFalse(register.isOverlong); assertEquals(8192, register.uInt32Value); } diff --git a/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java b/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java index 537ddd36..a06b3367 100644 --- a/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java +++ b/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java @@ -37,70 +37,70 @@ class TestDecodeByteVector { @WithByteBuf("80") void testNull(Collection buffers) { decode(nullableByteVectorDecoder, buffers, register); - assertTrue(nullableByteVectorDecoder.isReady()); + assertNull(register.byteVectorValue); } @WithByteBuf("81") void testNullableZeroLen(Collection buffers) { decode(nullableByteVectorDecoder, buffers, register); - assertTrue(nullableByteVectorDecoder.isReady()); + assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("80") void testMandatoryZeroLen(Collection buffers) { decode(mandatoryByteVectorDecoder, buffers, register); - assertTrue(mandatoryByteVectorDecoder.isReady()); + assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("10 00 00 00 81 41 42 42 43 44 45") void testNullableLengthOverflow1(Collection buffers) { decode(nullableByteVectorDecoder, buffers, register); - assertTrue(nullableByteVectorDecoder.isReady()); + assertTrue(register.isOverflow); } @WithByteBuf("10 00 00 00 00 00 80 41 42 42 43 44 45") void testNullableLengthOverflow2(Collection buffers) { decode(nullableByteVectorDecoder, buffers, register); - assertTrue(nullableByteVectorDecoder.isReady()); + assertTrue(register.isOverflow); } @WithByteBuf("10 00 00 00 80 41 42 42 43 44 45") void testMandatoryLengthOverflow1(Collection buffers) { decode(mandatoryByteVectorDecoder, buffers, register); - assertTrue(mandatoryByteVectorDecoder.isReady()); + assertTrue(register.isOverflow); } @WithByteBuf("0f 7f 7f 7f 7f 00 ff 41 42 42 43 44 45") void testMandatoryLengthOverflow2(Collection buffers) { decode(mandatoryByteVectorDecoder, buffers, register); - assertTrue(mandatoryByteVectorDecoder.isReady()); + assertTrue(register.isOverflow); } @WithByteBuf("87 41 42 42 43 44 45") void testSimpleNullableVector(Collection buffers) { decode(nullableByteVectorDecoder, buffers, register); - assertTrue(nullableByteVectorDecoder.isReady()); + assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("86 41 42 42 43 44 45") void testSimpleMandatoryVector(Collection buffers) { decode(mandatoryByteVectorDecoder, buffers, register); - assertTrue(mandatoryByteVectorDecoder.isReady()); + assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("81") void testNullableZeroLenGetValueTwice(Collection buffers) { decode(nullableByteVectorDecoder, buffers, register); - assertTrue(nullableByteVectorDecoder.isReady()); + assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @@ -108,7 +108,7 @@ void testNullableZeroLenGetValueTwice(Collection buffers) { @WithByteBuf("80") void testMandatoryZeroLenGetValueTwice(Collection buffers) { decode(mandatoryByteVectorDecoder, buffers, register); - assertTrue(mandatoryByteVectorDecoder.isReady()); + assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @@ -116,22 +116,22 @@ void testMandatoryZeroLenGetValueTwice(Collection buffers) { @WithByteBuf("87 41 42 42 43 44 45 81") void testSimpleNullableVectorTwoValuesInRow(Collection buffers) { decode(nullableByteVectorDecoder, buffers, register); - assertTrue(nullableByteVectorDecoder.isReady()); + assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); decode(nullableByteVectorDecoder, buffers, register); - assertTrue(nullableByteVectorDecoder.isReady()); + assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("86 41 42 42 43 44 45 80") void testSimpleMandatoryVectorTwoValuesInRow(Collection buffers) { decode(mandatoryByteVectorDecoder, buffers, register); - assertTrue(mandatoryByteVectorDecoder.isReady()); + assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); decode(mandatoryByteVectorDecoder, buffers, register); - assertTrue(mandatoryByteVectorDecoder.isReady()); + assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } } From 43a1e646bb94338c51978d51369783a2dd0ee78a Mon Sep 17 00:00:00 2001 From: vdonadze Date: Thu, 6 Aug 2020 12:53:34 +0400 Subject: [PATCH 08/20] removed startDecode and continueDecode --- .../epfast/decoder/IDecodeContext.java | 14 +- .../decoder/ascii/DecodeAsciiString.java | 13 -- .../epfast/decoder/decimal/DecodeDecimal.java | 14 +- .../decimal/DecodeMandatoryDecimal.java | 139 ++++++++-------- .../decimal/DecodeNullableDecimal.java | 153 ++++++++---------- .../epfast/decoder/integer/DecodeInteger.java | 12 +- .../decoder/integer/DecodeMandatoryInt32.java | 117 ++++++-------- .../decoder/integer/DecodeMandatoryInt64.java | 117 ++++++-------- .../integer/DecodeMandatoryUInt32.java | 21 +-- .../integer/DecodeMandatoryUInt64.java | 69 ++++---- .../decoder/integer/DecodeNullableInt32.java | 121 +++++++------- .../decoder/integer/DecodeNullableInt64.java | 116 +++++++------ .../decoder/integer/DecodeNullableUInt32.java | 27 +--- .../decoder/integer/DecodeNullableUInt64.java | 72 ++++----- .../presencemap/DecodePresenceMap.java | 25 +-- .../decoder/unicode/DecodeByteVector.java | 25 +-- .../unicode/DecodeMandatoryByteVector.java | 113 +++++++------ .../unicode/DecodeNullableByteVector.java | 113 +++++++------ .../epfast/decoder/integer/TestInt32.java | 41 ----- .../epfast/decoder/integer/TestInt64.java | 41 ----- .../epfast/decoder/integer/TestUInt32.java | 22 --- .../decoder/unicode/TestDecodeByteVector.java | 15 -- 22 files changed, 539 insertions(+), 861 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java index bbd1574f..9e2d9886 100644 --- a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java +++ b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java @@ -27,17 +27,5 @@ public interface IDecodeContext { int CLEAR_STOP_BIT_MASK = 0b01111111; - int startDecode(ByteBuf buf, UnionRegister register); - - int continueDecode(ByteBuf buf, UnionRegister register); - - boolean inProgress(); - - default int decode(ByteBuf buf, UnionRegister register) { - if (!inProgress()) { - return startDecode(buf, register); - } else { - return continueDecode(buf, register); - } - } + int decode(ByteBuf buf, UnionRegister register); } diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java index f42cdbd3..9c8b1bb4 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java @@ -38,14 +38,6 @@ public abstract class DecodeAsciiString implements IDecodeContext { this.checkOverlong = checkOverlong; } - public int startDecode(ByteBuf buf, UnionRegister register) { - throw new UnsupportedOperationException(); - } - - public int continueDecode(ByteBuf buf, UnionRegister register) { - throw new UnsupportedOperationException(); - } - @Override public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); @@ -99,9 +91,4 @@ public final void reset() { decodingPreamble = true; zeroCount = 0; } - - @Override - public boolean inProgress() { - throw new UnsupportedOperationException(); - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java index 2f9df30c..8554ba4d 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java @@ -19,7 +19,6 @@ import com.exactpro.epfast.decoder.IDecodeContext; import com.exactpro.epfast.decoder.integer.DecodeMandatoryInt64; import com.exactpro.epfast.decoder.message.UnionRegister; -import io.netty.buffer.ByteBuf; public abstract class DecodeDecimal implements IDecodeContext { @@ -43,22 +42,15 @@ public abstract class DecodeDecimal implements IDecodeContext { protected boolean inProgress; - public abstract int startDecode(ByteBuf buf, UnionRegister register); - - public abstract int continueDecode(ByteBuf buf, UnionRegister register); - public final void reset() { exponentReady = false; startedMantissa = false; ready = false; exponentOverflow = false; mantissaOverflow = false; + exponentOverlong = false; + mantissaOverlong = false; } - public abstract void setRegisterValue(UnionRegister register); - - @Override - public boolean inProgress() { - return inProgress; - } + public abstract void setResult(UnionRegister register); } diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java index 6fc4aabb..aa6cc20b 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java @@ -28,75 +28,11 @@ public final class DecodeMandatoryDecimal extends DecodeDecimal { private int exponent; - public int startDecode(ByteBuf buf, UnionRegister register) { - reset(); - inProgress = true; - exponentDecoder.startDecode(buf, register); - if (exponentDecoder.isReady()) { - exponentReady = true; - if (register.isOverlong) { - exponentOverlong = true; - } - if (register.isOverflow) { - exponentOverflow = true; - } else { - exponent = register.int32Value; - } - if (buf.isReadable()) { - mantissaDecoder.startDecode(buf, register); - startedMantissa = true; - if (mantissaDecoder.isReady()) { - ready = true; - if (register.isOverlong) { - mantissaOverlong = true; - } - if (register.isOverflow) { - mantissaOverflow = true; - } else { - mantissa = register.int64Value; - } - } - } - } - if (ready) { - setRegisterValue(register); - return 1; - } else { - return 0; - } - } - - public int continueDecode(ByteBuf buf, UnionRegister register) { - if (exponentReady && startedMantissa) { - mantissaDecoder.continueDecode(buf, register); - if (mantissaDecoder.isReady()) { - ready = true; - if (register.isOverlong) { - mantissaOverlong = true; - } - if (register.isOverflow) { - mantissaOverflow = true; - } else { - mantissa = register.int64Value; - } - } - } else if (exponentReady) { - mantissaDecoder.startDecode(buf, register); - startedMantissa = true; - if (mantissaDecoder.isReady()) { - ready = true; - if (register.isOverlong) { - mantissaOverlong = true; - } - if (register.isOverflow) { - mantissaOverflow = true; - } else { - mantissa = register.int64Value; - } - } - } else { - exponentDecoder.continueDecode(buf, register); - if (exponentDecoder.isReady()) { + @Override + public int decode(ByteBuf buf, UnionRegister register) { + if (!inProgress) { + inProgress = true; + if (exponentDecoder.decode(buf, register) == FINISHED) { exponentReady = true; if (register.isOverlong) { exponentOverlong = true; @@ -107,9 +43,8 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { exponent = register.int32Value; } if (buf.isReadable()) { - mantissaDecoder.startDecode(buf, register); startedMantissa = true; - if (mantissaDecoder.isReady()) { + if (mantissaDecoder.decode(buf, register) == FINISHED) { ready = true; if (register.isOverlong) { mantissaOverlong = true; @@ -122,16 +57,69 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { } } } + } else { + if (exponentReady && startedMantissa) { + if (mantissaDecoder.decode(buf, register) == FINISHED) { + ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } + if (register.isOverflow) { + mantissaOverflow = true; + } else { + mantissa = register.int64Value; + } + } + } else if (exponentReady) { + startedMantissa = true; + if (mantissaDecoder.decode(buf, register) == FINISHED) { + ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } + if (register.isOverflow) { + mantissaOverflow = true; + } else { + mantissa = register.int64Value; + } + } + } else { + if (exponentDecoder.decode(buf, register) == FINISHED) { + exponentReady = true; + if (register.isOverlong) { + exponentOverlong = true; + } + if (register.isOverflow) { + exponentOverflow = true; + } else { + exponent = register.int32Value; + } + if (buf.isReadable()) { + startedMantissa = true; + if (mantissaDecoder.decode(buf, register) == FINISHED) { + ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } + if (register.isOverflow) { + mantissaOverflow = true; + } else { + mantissa = register.int64Value; + } + } + } + } + } } if (ready) { - setRegisterValue(register); - return 1; + setResult(register); + return FINISHED; } else { - return 0; + return MORE_DATA_NEEDED; } } - public void setRegisterValue(UnionRegister register) { + public void setResult(UnionRegister register) { inProgress = false; register.isOverlong = exponentOverlong || mantissaOverlong; if (exponentOverflow) { @@ -148,5 +136,6 @@ public void setRegisterValue(UnionRegister register) { register.isOverflow = true; register.infoMessage = "exponent value allowed range is -63 ... 63"; } + reset(); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java index 8178a3b4..53fe27c9 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java @@ -30,80 +30,11 @@ public final class DecodeNullableDecimal extends DecodeDecimal { private boolean nullValue; - public int startDecode(ByteBuf buf, UnionRegister register) { - reset(); - inProgress = true; - exponentDecoder.startDecode(buf, register); - if (exponentDecoder.isReady()) { - exponentReady = true; - if (register.isOverlong) { - exponentOverlong = true; - } - if (register.isOverflow) { - exponentOverflow = true; - } else { - exponent = register.int32Value; - } - if (!register.isNull && buf.isReadable()) { - mantissaDecoder.startDecode(buf, register); - startedMantissa = true; - if (mantissaDecoder.isReady()) { - ready = true; - if (register.isOverlong) { - mantissaOverlong = true; - } - if (register.isOverflow) { - mantissaOverflow = true; - } else { - mantissa = register.int64Value; - } - } - } else if (register.isNull) { - nullValue = true; - ready = true; - setRegisterValue(register); - return 1; - } - } - if (ready) { - setRegisterValue(register); - return 1; - } else { - return 0; - } - } - - public int continueDecode(ByteBuf buf, UnionRegister register) { - if (exponentReady && startedMantissa) { - mantissaDecoder.continueDecode(buf, register); - if (mantissaDecoder.isReady()) { - ready = true; - if (register.isOverlong) { - mantissaOverlong = true; - } - if (register.isOverflow) { - mantissaOverflow = true; - } else { - mantissa = register.int64Value; - } - } - } else if (exponentReady) { - startedMantissa = true; - mantissaDecoder.startDecode(buf, register); - if (mantissaDecoder.isReady()) { - ready = true; - if (register.isOverlong) { - mantissaOverlong = true; - } - if (register.isOverflow) { - mantissaOverflow = true; - } else { - mantissa = register.int64Value; - } - } - } else { - exponentDecoder.continueDecode(buf, register); - if (exponentDecoder.isReady()) { + @Override + public int decode(ByteBuf buf, UnionRegister register) { + if (!inProgress) { + inProgress = true; + if (exponentDecoder.decode(buf, register) == FINISHED) { exponentReady = true; if (register.isOverlong) { exponentOverlong = true; @@ -114,9 +45,8 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { exponent = register.int32Value; } if (!register.isNull && buf.isReadable()) { - mantissaDecoder.startDecode(buf, register); startedMantissa = true; - if (mantissaDecoder.isReady()) { + if (mantissaDecoder.decode(buf, register) == FINISHED) { ready = true; if (register.isOverlong) { mantissaOverlong = true; @@ -130,21 +60,79 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { } else if (register.isNull) { nullValue = true; ready = true; - setRegisterValue(register); - return 1; + setResult(register); + return FINISHED; + } + } + } else { + if (exponentReady && startedMantissa) { + if (mantissaDecoder.decode(buf, register) == FINISHED) { + ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } + if (register.isOverflow) { + mantissaOverflow = true; + } else { + mantissa = register.int64Value; + } + } + } else if (exponentReady) { + startedMantissa = true; + if (mantissaDecoder.decode(buf, register) == FINISHED) { + ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } + if (register.isOverflow) { + mantissaOverflow = true; + } else { + mantissa = register.int64Value; + } + } + } else { + if (exponentDecoder.decode(buf, register) == FINISHED) { + exponentReady = true; + if (register.isOverlong) { + exponentOverlong = true; + } + if (register.isOverflow) { + exponentOverflow = true; + } else { + exponent = register.int32Value; + } + if (!register.isNull && buf.isReadable()) { + startedMantissa = true; + if (mantissaDecoder.decode(buf, register) == FINISHED) { + ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } + if (register.isOverflow) { + mantissaOverflow = true; + } else { + mantissa = register.int64Value; + } + } + } else if (register.isNull) { + nullValue = true; + ready = true; + setResult(register); + return FINISHED; + } } } } if (ready) { - setRegisterValue(register); - return 1; + setResult(register); + return FINISHED; } else { - return 0; + return MORE_DATA_NEEDED; } } @Override - public void setRegisterValue(UnionRegister register) { + public void setResult(UnionRegister register) { inProgress = false; register.isOverlong = exponentOverlong || mantissaOverlong; if (exponentOverflow) { @@ -164,5 +152,6 @@ public void setRegisterValue(UnionRegister register) { register.isOverflow = true; register.infoMessage = "exponent value allowed range is -63 ... 63"; } + reset(); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java index a19bd08c..d2ddfee6 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java @@ -18,7 +18,6 @@ import com.exactpro.epfast.decoder.IDecodeContext; import com.exactpro.epfast.decoder.message.UnionRegister; -import io.netty.buffer.ByteBuf; public abstract class DecodeInteger implements IDecodeContext { @@ -30,10 +29,6 @@ public abstract class DecodeInteger implements IDecodeContext { boolean checkForSignExtension = false; - public abstract int startDecode(ByteBuf buf, UnionRegister register); - - public abstract int continueDecode(ByteBuf buf, UnionRegister register); - protected boolean inProgress; protected final void reset() { @@ -49,10 +44,5 @@ static void longToBytes(long value, byte[] bytes) { } } - public abstract void setRegisterValue(UnionRegister register); - - @Override - public boolean inProgress() { - return inProgress; - } + public abstract void setResult(UnionRegister register); } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java index 24f7a08c..66704e09 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java @@ -27,85 +27,76 @@ public final class DecodeMandatoryInt32 extends DecodeInteger { private int value; - public int startDecode(ByteBuf buf, UnionRegister register) { - reset(); - inProgress = true; + @Override + public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); - int oneByte = buf.getByte(readerIndex++); - if ((oneByte & SIGN_BIT_MASK) == 0) { - value = 0; - accumulatePositive(oneByte); - if (oneByte < 0) { - setRegisterValue(register); - buf.readerIndex(readerIndex); - return 1; + if (!inProgress) { + inProgress = true; + int oneByte = buf.getByte(readerIndex++); + if ((oneByte & SIGN_BIT_MASK) == 0) { + value = 0; + accumulatePositive(oneByte); + if (oneByte < 0) { + setResult(register); + buf.readerIndex(readerIndex); + return FINISHED; + } + if (readerIndex < readLimit) { + checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte + do { + accumulatePositive(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } else { + checkForSignExtension = true; + } + } else { + value = -1; + accumulateNegative(oneByte); + if (oneByte < 0) { + buf.readerIndex(readerIndex); + setResult(register); + return FINISHED; + } + if (readerIndex < readLimit) { + checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte + do { + accumulateNegative(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } else { + checkForSignExtension = true; + } } - if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte + } else { + if (value >= 0) { + if (checkForSignExtension) { + checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking + checkForSignExtension = false; + } do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); } else { - checkForSignExtension = true; - } - } else { - value = -1; - accumulateNegative(oneByte); - if (oneByte < 0) { - setRegisterValue(register); - buf.readerIndex(readerIndex); - return 1; - } - if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte + if (checkForSignExtension) { + checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes + checkForSignExtension = false; + } do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } } buf.readerIndex(readerIndex); if (ready) { - setRegisterValue(register); - return 1; + setResult(register); + return FINISHED; } else { - return 0; - } - } - - public int continueDecode(ByteBuf buf, UnionRegister register) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (value >= 0) { - if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking - checkForSignExtension = false; - } - do { - accumulatePositive(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } else { - if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes - checkForSignExtension = false; - } - do { - accumulateNegative(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } - buf.readerIndex(readerIndex); - if (ready) { - setRegisterValue(register); - return 1; - } else { - return 0; + return MORE_DATA_NEEDED; } } @Override - public void setRegisterValue(UnionRegister register) { + public void setResult(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; @@ -115,6 +106,7 @@ public void setRegisterValue(UnionRegister register) { register.isNull = false; register.int32Value = value; } + reset(); } private void accumulatePositive(int oneByte) { @@ -148,9 +140,4 @@ private void checkOverlongPositive(int secondByte, UnionRegister register) { private void checkOverlongNegative(int secondByte, UnionRegister register) { register.isOverlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); } - - //TODO remove - public boolean isReady() { - return ready; - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java index 5c2ca7af..693d4a02 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java @@ -27,85 +27,76 @@ public final class DecodeMandatoryInt64 extends DecodeInteger { private long value; - public int startDecode(ByteBuf buf, UnionRegister register) { - reset(); - inProgress = true; + @Override + public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); - int oneByte = buf.getByte(readerIndex++); - if ((oneByte & SIGN_BIT_MASK) == 0) { - value = 0; - accumulatePositive(oneByte); - if (oneByte < 0) { - setRegisterValue(register); - buf.readerIndex(readerIndex); - return 1; + if (!inProgress) { + inProgress = true; + int oneByte = buf.getByte(readerIndex++); + if ((oneByte & SIGN_BIT_MASK) == 0) { + value = 0; + accumulatePositive(oneByte); + if (oneByte < 0) { + setResult(register); + buf.readerIndex(readerIndex); + return FINISHED; + } + if (readerIndex < readLimit) { + checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte + do { + accumulatePositive(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } else { + checkForSignExtension = true; + } + } else { + value = -1; + accumulateNegative(oneByte); + if (oneByte < 0) { + buf.readerIndex(readerIndex); + setResult(register); + return FINISHED; + } + if (readerIndex < readLimit) { + checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte + do { + accumulateNegative(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } else { + checkForSignExtension = true; + } } - if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte + } else { + if (value >= 0) { + if (checkForSignExtension) { + checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking + checkForSignExtension = false; + } do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); } else { - checkForSignExtension = true; - } - } else { - value = -1; - accumulateNegative(oneByte); - if (oneByte < 0) { - setRegisterValue(register); - buf.readerIndex(readerIndex); - return 1; - } - if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte + if (checkForSignExtension) { + checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes + checkForSignExtension = false; + } do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } } buf.readerIndex(readerIndex); if (ready) { - setRegisterValue(register); - return 1; + setResult(register); + return FINISHED; } else { - return 0; - } - } - - public int continueDecode(ByteBuf buf, UnionRegister register) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (value >= 0) { - if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking - checkForSignExtension = false; - } - do { - accumulatePositive(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } else { - if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes - checkForSignExtension = false; - } - do { - accumulateNegative(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } - buf.readerIndex(readerIndex); - if (ready) { - setRegisterValue(register); - return 1; - } else { - return 0; + return MORE_DATA_NEEDED; } } @Override - public void setRegisterValue(UnionRegister register) { + public void setResult(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; @@ -115,6 +106,7 @@ public void setRegisterValue(UnionRegister register) { register.isNull = false; register.int64Value = value; } + reset(); } private void accumulatePositive(int oneByte) { @@ -148,9 +140,4 @@ private void checkOverlongPositive(int secondByte, UnionRegister register) { private void checkOverlongNegative(int secondByte, UnionRegister register) { register.isOverlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); } - - //TODO remove - public boolean isReady() { - return ready; - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java index 92152280..5a2363c5 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java @@ -25,14 +25,6 @@ public final class DecodeMandatoryUInt32 extends DecodeInteger { private int value; - public int startDecode(ByteBuf buf, UnionRegister register) { - throw new UnsupportedOperationException(); - } - - public int continueDecode(ByteBuf buf, UnionRegister register) { - throw new UnsupportedOperationException(); - } - @Override public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); @@ -43,7 +35,7 @@ public int decode(ByteBuf buf, UnionRegister register) { int oneByte = buf.getByte(readerIndex++); accumulate(oneByte); if (oneByte < 0) { - setRegisterValue(register); + setResult(register); buf.readerIndex(readerIndex); return FINISHED; } @@ -66,8 +58,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } buf.readerIndex(readerIndex); if (ready) { - setRegisterValue(register); - reset(); + setResult(register); return FINISHED; } else { return MORE_DATA_NEEDED; @@ -75,7 +66,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } @Override - public void setRegisterValue(UnionRegister register) { + public void setResult(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; @@ -85,6 +76,7 @@ public void setRegisterValue(UnionRegister register) { register.isNull = false; register.uInt32Value = value & 0x0_FFFFFFFFL; } + reset(); } private void accumulate(int oneByte) { @@ -102,9 +94,4 @@ private void accumulate(int oneByte) { private void checkOverlong(int secondByte, UnionRegister register) { register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } - - //TODO remove - public boolean isReady() { - return ready; - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java index d56eaaaa..d4794652 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java @@ -29,57 +29,49 @@ public final class DecodeMandatoryUInt64 extends DecodeInteger { private long value; - public int startDecode(ByteBuf buf, UnionRegister register) { - reset(); - value = 0; - inProgress = true; + @Override + public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); - int oneByte = buf.getByte(readerIndex++); - accumulate(oneByte); - if (oneByte < 0) { - setRegisterValue(register); - buf.readerIndex(readerIndex); - return 1; - } - if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex), register); //check second byte + if (!inProgress) { + value = 0; + inProgress = true; + + int oneByte = buf.getByte(readerIndex++); + accumulate(oneByte); + if (oneByte < 0) { + setResult(register); + buf.readerIndex(readerIndex); + return FINISHED; + } + if (readerIndex < readLimit) { + checkOverlong(buf.getByte(readerIndex), register); //check second byte + do { + accumulate(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } else { + checkForSignExtension = true; + } + } else { + if (checkForSignExtension) { + checkOverlong(buf.getByte(readerIndex), register); //continue checking + checkForSignExtension = false; + } do { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; - } - buf.readerIndex(readerIndex); - if (ready) { - setRegisterValue(register); - return 1; - } else { - return 0; - } - } - - public int continueDecode(ByteBuf buf, UnionRegister register) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex), register); //continue checking - checkForSignExtension = false; } - do { - accumulate(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); buf.readerIndex(readerIndex); if (ready) { - setRegisterValue(register); - return 1; + setResult(register); + return FINISHED; } else { - return 0; + return MORE_DATA_NEEDED; } } @Override - public void setRegisterValue(UnionRegister register) { + public void setResult(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; @@ -90,6 +82,7 @@ public void setRegisterValue(UnionRegister register) { register.isNull = false; register.unsignedInt64Value = new BigInteger(1, bytes); } + reset(); } private void accumulate(int oneByte) { diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java index fd8b0918..39d95ee8 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java @@ -29,87 +29,78 @@ public final class DecodeNullableInt32 extends DecodeInteger { private int value; - public int startDecode(ByteBuf buf, UnionRegister register) { - reset(); - inProgress = true; + @Override + public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); - int oneByte = buf.getByte(readerIndex++); - if ((oneByte & SIGN_BIT_MASK) == 0) { - positive = true; - value = 0; - accumulatePositive(oneByte); - if (oneByte < 0) { - setRegisterValue(register); - buf.readerIndex(readerIndex); - return 1; + if (!inProgress) { + inProgress = true; + int oneByte = buf.getByte(readerIndex++); + if ((oneByte & SIGN_BIT_MASK) == 0) { + positive = true; + value = 0; + accumulatePositive(oneByte); + if (oneByte < 0) { + setResult(register); + buf.readerIndex(readerIndex); + return FINISHED; + } + if (readerIndex < readLimit) { + checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte + do { + accumulatePositive(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } else { + checkForSignExtension = true; + } + } else { + positive = false; + value = -1; + accumulateNegative(oneByte); + if (oneByte < 0) { + setResult(register); + buf.readerIndex(readerIndex); + return FINISHED; + } + if (readerIndex < readLimit) { + checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte + do { + accumulateNegative(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } else { + checkForSignExtension = true; + } } - if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte + } else { + if (value >= 0) { + if (checkForSignExtension) { + checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking + checkForSignExtension = false; + } do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); } else { - checkForSignExtension = true; - } - } else { - positive = false; - value = -1; - accumulateNegative(oneByte); - if (oneByte < 0) { - setRegisterValue(register); - buf.readerIndex(readerIndex); - return 1; - } - if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte + if (checkForSignExtension) { + checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes + checkForSignExtension = false; + } do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } } buf.readerIndex(readerIndex); if (ready) { - setRegisterValue(register); - return 1; + setResult(register); + return FINISHED; } else { - return 0; - } - } - - public int continueDecode(ByteBuf buf, UnionRegister register) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (value >= 0) { - if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking - checkForSignExtension = false; - } - do { - accumulatePositive(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } else { - if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes - checkForSignExtension = false; - } - do { - accumulateNegative(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } - buf.readerIndex(readerIndex); - if (ready) { - setRegisterValue(register); - return 1; - } else { - return 0; + return MORE_DATA_NEEDED; } } @Override - public void setRegisterValue(UnionRegister register) { + public void setResult(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; @@ -123,6 +114,7 @@ public void setRegisterValue(UnionRegister register) { register.int32Value = positive ? value - 1 : value; } } + reset(); } private void accumulatePositive(int oneByte) { @@ -158,9 +150,4 @@ private void checkOverlongPositive(int secondByte, UnionRegister register) { private void checkOverlongNegative(int secondByte, UnionRegister register) { register.isOverlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); } - - //TODO remove - public boolean isReady() { - return ready; - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java index 7a403ba8..b835c89b 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java @@ -29,87 +29,78 @@ public final class DecodeNullableInt64 extends DecodeInteger { private long value; - public int startDecode(ByteBuf buf, UnionRegister register) { - reset(); - inProgress = true; + @Override + public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); - int oneByte = buf.getByte(readerIndex++); - if ((oneByte & SIGN_BIT_MASK) == 0) { - positive = true; - value = 0; - accumulatePositive(oneByte); - if (oneByte < 0) { - setRegisterValue(register); - buf.readerIndex(readerIndex); - return 1; + if (!inProgress) { + inProgress = true; + int oneByte = buf.getByte(readerIndex++); + if ((oneByte & SIGN_BIT_MASK) == 0) { + positive = true; + value = 0; + accumulatePositive(oneByte); + if (oneByte < 0) { + setResult(register); + buf.readerIndex(readerIndex); + return FINISHED; + } + if (readerIndex < readLimit) { + checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte + do { + accumulatePositive(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } else { + checkForSignExtension = true; + } + } else { + positive = false; + value = -1; + accumulateNegative(oneByte); + if (oneByte < 0) { + setResult(register); + buf.readerIndex(readerIndex); + return FINISHED; + } + if (readerIndex < readLimit) { + checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte + do { + accumulateNegative(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } else { + checkForSignExtension = true; + } } - if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte + } else { + if (value >= 0) { + if (checkForSignExtension) { + checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking + checkForSignExtension = false; + } do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); } else { - checkForSignExtension = true; - } - } else { - positive = false; - value = -1; - accumulateNegative(oneByte); - if (oneByte < 0) { - setRegisterValue(register); - buf.readerIndex(readerIndex); - return 1; - } - if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte + if (checkForSignExtension) { + checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes + checkForSignExtension = false; + } do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } } buf.readerIndex(readerIndex); if (ready) { - setRegisterValue(register); - return 1; + setResult(register); + return FINISHED; } else { - return 0; - } - } - - public int continueDecode(ByteBuf buf, UnionRegister register) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (value >= 0) { - if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking - checkForSignExtension = false; - } - do { - accumulatePositive(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } else { - if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes - checkForSignExtension = false; - } - do { - accumulateNegative(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } - buf.readerIndex(readerIndex); - if (ready) { - setRegisterValue(register); - return 1; - } else { - return 0; + return MORE_DATA_NEEDED; } } @Override - public void setRegisterValue(UnionRegister register) { + public void setResult(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; @@ -123,6 +114,7 @@ public void setRegisterValue(UnionRegister register) { register.int64Value = positive ? value - 1 : value; } } + reset(); } private void accumulatePositive(int oneByte) { diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java index cb06d49b..1bb7b0c3 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java @@ -27,14 +27,6 @@ public final class DecodeNullableUInt32 extends DecodeInteger { private int value; - public int startDecode(ByteBuf buf, UnionRegister register) { - throw new UnsupportedOperationException(); - } - - public int continueDecode(ByteBuf buf, UnionRegister register) { - throw new UnsupportedOperationException(); - } - @Override public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); @@ -46,9 +38,9 @@ public int decode(ByteBuf buf, UnionRegister register) { int oneByte = buf.getByte(readerIndex++); accumulate(oneByte); if (oneByte < 0) { - setRegisterValue(register); + setResult(register); buf.readerIndex(readerIndex); - return 1; + return FINISHED; } if (readerIndex < readLimit) { checkOverlong(buf.getByte(readerIndex), register); //check second byte @@ -69,16 +61,15 @@ public int decode(ByteBuf buf, UnionRegister register) { } buf.readerIndex(readerIndex); if (ready) { - setRegisterValue(register); - reset(); - return 1; + setResult(register); + return FINISHED; } else { - return 0; + return MORE_DATA_NEEDED; } } @Override - public void setRegisterValue(UnionRegister register) { + public void setResult(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; @@ -91,6 +82,7 @@ public void setRegisterValue(UnionRegister register) { register.isNull = false; register.uInt32Value = isUInt32Limit ? 0x0_FFFFFFFFL : value - 1 & 0x0_FFFFFFFFL; } + reset(); } private void accumulate(int oneByte) { @@ -110,9 +102,4 @@ private void accumulate(int oneByte) { private void checkOverlong(int secondByte, UnionRegister register) { register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } - - //TODO remove - public boolean isReady() { - return ready; - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java index 6875fa1a..06c862d5 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java @@ -31,58 +31,51 @@ public final class DecodeNullableUInt64 extends DecodeInteger { private long value; - public int startDecode(ByteBuf buf, UnionRegister register) { - reset(); - value = 0; - isUInt64Limit = false; - inProgress = true; + @Override + public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); - int oneByte = buf.getByte(readerIndex++); - accumulate(oneByte); - if (oneByte < 0) { - setRegisterValue(register); - buf.readerIndex(readerIndex); - return 1; - } - if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex), register); //check second byte + if (!inProgress) { + + value = 0; + isUInt64Limit = false; + inProgress = true; + + int oneByte = buf.getByte(readerIndex++); + accumulate(oneByte); + if (oneByte < 0) { + setResult(register); + buf.readerIndex(readerIndex); + return FINISHED; + } + if (readerIndex < readLimit) { + checkOverlong(buf.getByte(readerIndex), register); //check second byte + do { + accumulate(buf.getByte(readerIndex++)); + } while (!ready && readerIndex < readLimit); + } else { + checkForSignExtension = true; + } + } else { + if (checkForSignExtension) { + checkOverlong(buf.getByte(readerIndex), register); //continue checking + checkForSignExtension = false; + } do { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } buf.readerIndex(readerIndex); if (ready) { - setRegisterValue(register); - return 1; + setResult(register); + return FINISHED; } else { - return 0; - } - } - - public int continueDecode(ByteBuf buf, UnionRegister register) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex), register); //continue checking - checkForSignExtension = false; - } - do { - accumulate(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - buf.readerIndex(readerIndex); - if (ready) { - setRegisterValue(register); - return 1; - } else { - return 0; + return MORE_DATA_NEEDED; } } @Override - public void setRegisterValue(UnionRegister register) { + public void setResult(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; @@ -100,6 +93,7 @@ public void setRegisterValue(UnionRegister register) { } register.unsignedInt64Value = new BigInteger(1, bytes); } + reset(); } private void accumulate(int oneByte) { diff --git a/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java b/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java index 6a258a07..8a8e5d2e 100644 --- a/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java +++ b/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java @@ -32,14 +32,6 @@ public class DecodePresenceMap implements IDecodeContext { private boolean ready; - public int startDecode(ByteBuf buf, UnionRegister register) { - throw new UnsupportedOperationException(); - } - - public int continueDecode(ByteBuf buf, UnionRegister register) { - throw new UnsupportedOperationException(); - } - @Override public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); @@ -49,7 +41,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } buf.readerIndex(readerIndex); if (ready) { - setRegisterValue(register); + setResult(register); reset(); return FINISHED; } else { @@ -57,19 +49,11 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - public void setRegisterValue(UnionRegister register) { + public void setResult(UnionRegister register) { register.isOverlong = setIndex > lastNonZeroIndex; register.presenceMap = new PresenceMap((BitSet) value.clone()); } - public boolean isReady() { - return ready; - } - - public boolean isOverlong() { - throw new UnsupportedOperationException(); - } - private void accumulateValue(int oneByte) { if (oneByte < 0) { // if stop bit is set oneByte &= CLEAR_STOP_BIT_MASK; @@ -89,10 +73,5 @@ public final void reset() { setIndex = 0; lastNonZeroIndex = 0; } - - @Override - public boolean inProgress() { - throw new UnsupportedOperationException(); - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java index 0cffd718..c4945662 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java @@ -18,14 +18,13 @@ import com.exactpro.epfast.decoder.IDecodeContext; import com.exactpro.epfast.decoder.message.UnionRegister; -import io.netty.buffer.ByteBuf; import java.util.ArrayList; import java.util.List; public abstract class DecodeByteVector implements IDecodeContext { - List value; + List value = new ArrayList<>(); int counter; @@ -37,23 +36,7 @@ public abstract class DecodeByteVector implements IDecodeContext { protected boolean inProgress; - public abstract int startDecode(ByteBuf buf, UnionRegister register); - - public abstract int continueDecode(ByteBuf buf, UnionRegister register); - - public abstract void setRegisterValue(UnionRegister register); - - public boolean isReady() { - return ready; - } - - public boolean isOverflow() { - return overflow; - } - - public boolean isOverlong() { - return false; - } + public abstract void setResult(UnionRegister register); public final void reset() { lengthReady = false; @@ -63,10 +46,6 @@ public final void reset() { value = new ArrayList<>(); } - @Override - public boolean inProgress() { - return inProgress; - } } diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java index 245467a1..2bcaa750 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java @@ -26,63 +26,36 @@ public final class DecodeMandatoryByteVector extends DecodeByteVector { private long messageLength; - public int startDecode(ByteBuf buf, UnionRegister register) { - reset(); - inProgress = true; - if (lengthDecoder.decode(buf, register) == FINISHED) { - lengthReady = true; - if (register.isOverflow) { - overflow = true; - } else { - messageLength = register.uInt32Value; - } - if (messageLength > 0) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - while ((readerIndex < readLimit) && !ready) { - if (counter < messageLength) { - value.add(buf.getByte(readerIndex++)); - counter++; - } - if (counter == messageLength) { - ready = true; - } - } - buf.readerIndex(readerIndex); - } else { - ready = true; - } - } - if (ready) { - setRegisterValue(register); - return 1; - } else { - return 0; - } - } - - public int continueDecode(ByteBuf buf, UnionRegister register) { - if (lengthReady) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - while ((readerIndex < readLimit) && !ready) { - if (counter < messageLength) { - value.add(buf.getByte(readerIndex++)); - counter++; + @Override + public int decode(ByteBuf buf, UnionRegister register) { + if (!inProgress) { + inProgress = true; + if (lengthDecoder.decode(buf, register) == FINISHED) { + lengthReady = true; + if (register.isOverflow) { + overflow = true; + } else { + messageLength = register.uInt32Value; } - if (counter == messageLength) { + if (messageLength > 0) { + int readerIndex = buf.readerIndex(); + int readLimit = buf.writerIndex(); + while ((readerIndex < readLimit) && !ready) { + if (counter < messageLength) { + value.add(buf.getByte(readerIndex++)); + counter++; + } + if (counter == messageLength) { + ready = true; + } + } + buf.readerIndex(readerIndex); + } else { ready = true; } } - buf.readerIndex(readerIndex); - } else if (lengthDecoder.decode(buf, register) == FINISHED) { - lengthReady = true; - if (register.isOverflow) { - overflow = true; - } else { - messageLength = register.uInt32Value; - } - if (messageLength > 0) { + } else { + if (lengthReady) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); while ((readerIndex < readLimit) && !ready) { @@ -95,20 +68,41 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { } } buf.readerIndex(readerIndex); - } else { - ready = true; + } else if (lengthDecoder.decode(buf, register) == FINISHED) { + lengthReady = true; + if (register.isOverflow) { + overflow = true; + } else { + messageLength = register.uInt32Value; + } + if (messageLength > 0) { + int readerIndex = buf.readerIndex(); + int readLimit = buf.writerIndex(); + while ((readerIndex < readLimit) && !ready) { + if (counter < messageLength) { + value.add(buf.getByte(readerIndex++)); + counter++; + } + if (counter == messageLength) { + ready = true; + } + } + buf.readerIndex(readerIndex); + } else { + ready = true; + } } } if (ready) { - setRegisterValue(register); - return 1; + setResult(register); + return FINISHED; } else { - return 0; + return MORE_DATA_NEEDED; } } @Override - public void setRegisterValue(UnionRegister register) { + public void setResult(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; @@ -122,5 +116,6 @@ public void setRegisterValue(UnionRegister register) { register.isNull = false; register.byteVectorValue = finalVal; } + reset(); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java index 98ac1417..12eed12f 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java @@ -26,63 +26,36 @@ public final class DecodeNullableByteVector extends DecodeByteVector { private long messageLength; - public int startDecode(ByteBuf buf, UnionRegister register) { - reset(); - inProgress = true; - if (lengthDecoder.decode(buf, register) == FINISHED) { - lengthReady = true; - if (register.isOverflow) { - overflow = true; - } else { - messageLength = register.uInt32Value; - } - if (!register.isNull && messageLength > 0) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - while ((readerIndex < readLimit) && !ready) { - if (counter < messageLength) { - value.add(buf.getByte(readerIndex++)); - counter++; - } - if (counter == messageLength) { - ready = true; - } - } - buf.readerIndex(readerIndex); - } else { - ready = true; - } - } - if (ready) { - setRegisterValue(register); - return FINISHED; - } else { - return MORE_DATA_NEEDED; - } - } - - public int continueDecode(ByteBuf buf, UnionRegister register) { - if (lengthReady) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - while ((readerIndex < readLimit) && !ready) { - if (counter < messageLength) { - value.add(buf.getByte(readerIndex++)); - counter++; + @Override + public int decode(ByteBuf buf, UnionRegister register) { + if (!inProgress) { + inProgress = true; + if (lengthDecoder.decode(buf, register) == FINISHED) { + lengthReady = true; + if (register.isOverflow) { + overflow = true; + } else { + messageLength = register.uInt32Value; } - if (counter == messageLength) { + if (!register.isNull && messageLength > 0) { + int readerIndex = buf.readerIndex(); + int readLimit = buf.writerIndex(); + while ((readerIndex < readLimit) && !ready) { + if (counter < messageLength) { + value.add(buf.getByte(readerIndex++)); + counter++; + } + if (counter == messageLength) { + ready = true; + } + } + buf.readerIndex(readerIndex); + } else { ready = true; } } - buf.readerIndex(readerIndex); - } else if (lengthDecoder.decode(buf, register) == FINISHED) { - lengthReady = true; - if (register.isOverflow) { - overflow = true; - } else { - messageLength = register.uInt32Value; - } - if (!register.isNull && messageLength > 0) { + } else { + if (lengthReady) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); while ((readerIndex < readLimit) && !ready) { @@ -95,20 +68,41 @@ public int continueDecode(ByteBuf buf, UnionRegister register) { } } buf.readerIndex(readerIndex); - } else { - ready = true; + } else if (lengthDecoder.decode(buf, register) == FINISHED) { + lengthReady = true; + if (register.isOverflow) { + overflow = true; + } else { + messageLength = register.uInt32Value; + } + if (!register.isNull && messageLength > 0) { + int readerIndex = buf.readerIndex(); + int readLimit = buf.writerIndex(); + while ((readerIndex < readLimit) && !ready) { + if (counter < messageLength) { + value.add(buf.getByte(readerIndex++)); + counter++; + } + if (counter == messageLength) { + ready = true; + } + } + buf.readerIndex(readerIndex); + } else { + ready = true; + } } } if (ready) { - setRegisterValue(register); - return 1; + setResult(register); + return FINISHED; } else { - return 0; + return MORE_DATA_NEEDED; } } @Override - public void setRegisterValue(UnionRegister register) { + public void setResult(UnionRegister register) { inProgress = false; if (overflow) { register.isOverflow = true; @@ -125,5 +119,6 @@ public void setRegisterValue(UnionRegister register) { register.byteVectorValue = finalVal; } } + reset(); } } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java index a41d1855..52e2b524 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java @@ -37,226 +37,192 @@ class TestInt32 { @WithByteBuf("80") void testNull(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertTrue(register.isNull); } @WithByteBuf("81") void optionalZero(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertEquals(0, register.int32Value); } @WithByteBuf("80") void mandatoryZero(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertEquals(0, register.int32Value); } @WithByteBuf("08 00 00 00 80") void testMaxNullable(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertEquals(Integer.MAX_VALUE, register.int32Value); } @WithByteBuf("07 7f 7f 7f ff") void testMaxMandatory(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertEquals(Integer.MAX_VALUE, register.int32Value); } @WithByteBuf("78 00 00 00 80") void testMinNullable(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertEquals(Integer.MIN_VALUE, register.int32Value); } @WithByteBuf("78 00 00 00 80") void testMinMandatory(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertEquals(Integer.MIN_VALUE, register.int32Value); } @WithByteBuf("08 00 00 00 81") void testMaxOverflowNullable1(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("08 00 00 00 00 00 00 80") void testMaxOverflowNullable2(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("08 00 00 00 80") void testMaxOverflowMandatory1(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("07 7f 00 7f 7f 7f ff") void testMaxOverflowMandatory2(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("77 7f 7f 7f ff") void testMinOverflowNullable1(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("78 00 00 00 00 80") void testMinOverflowNullable2(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("77 7f 7f 7f ff") void testMinOverflowMandatory1(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("78 00 00 00 00 80") void testMinOverflowMandatory2(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("39 45 a4") void optionalPositive(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertEquals(942755, register.int32Value); } @WithByteBuf("39 45 a3") void mandatoryPositive(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertEquals(942755, register.int32Value); } @WithByteBuf("46 3a dd") void optionalNegative(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertEquals(-942755, register.int32Value); } @WithByteBuf("7c 1b 1b 9d") void mandatoryNegative(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertEquals(-7942755, register.int32Value); } @WithByteBuf("ff") void optionalMinusOne(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertEquals(-1, register.int32Value); } @WithByteBuf("ff") void mandatoryMinusOne(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertEquals(-1, register.int32Value); } @WithByteBuf("00 00 40 82") void optionalSignExtensionPositive(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertEquals(8193, register.int32Value); } @WithByteBuf("00 00 40 81") void mandatorySignExtensionPositive(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertEquals(8193, register.int32Value); } @WithByteBuf("7f 3f ff") void optionalSignExtensionNegative(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertEquals(-8193, register.int32Value); } @WithByteBuf("7f 3f ff") void mandatorySignExtensionNegative(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertEquals(-8193, register.int32Value); } @WithByteBuf("7f 3f ff 7f 3f ff") void mandatoryNegativeTwoValuesInRow(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertEquals(-8193, register.int32Value); decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertEquals(-8193, register.int32Value); } @WithByteBuf("00 00 40 81 00 00 40 81") void mandatoryPositiveTwoValuesInRow(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertEquals(8193, register.int32Value); decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertEquals(8193, register.int32Value); } @WithByteBuf("7f 3f ff 7f 3f ff") void optionalNegativeTwoValuesInRow(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertEquals(-8193, register.int32Value); decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertEquals(-8193, register.int32Value); } @WithByteBuf("00 00 40 82 00 00 40 82") void optionalPositiveTwoValuesInRow(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertEquals(8193, register.int32Value); decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertEquals(8193, register.int32Value); } @WithByteBuf("00 39 45 a4") void mandatoryOverlong(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertTrue(register.isOverlong); assertEquals(942756, register.int32Value); } @@ -264,7 +230,6 @@ void mandatoryOverlong(Collection buffers) { @WithByteBuf("00 40 81") void mandatoryNotOverlong(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertFalse(register.isOverlong); assertEquals(8193, register.int32Value); } @@ -272,7 +237,6 @@ void mandatoryNotOverlong(Collection buffers) { @WithByteBuf("7f 7c 1b 1b 9d") void mandatoryOverlongNegative(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertTrue(register.isOverlong); assertEquals(-7942755, register.int32Value); } @@ -280,7 +244,6 @@ void mandatoryOverlongNegative(Collection buffers) { @WithByteBuf("7f 3f ff") void mandatoryNotOverlongNegative(Collection buffers) { decode(mandatoryInt32Decoder, buffers, register); - assertTrue(mandatoryInt32Decoder.isReady()); assertFalse(register.isOverlong); assertEquals(-8193, register.int32Value); } @@ -288,7 +251,6 @@ void mandatoryNotOverlongNegative(Collection buffers) { @WithByteBuf("00 39 45 a4") void nullableOverlong(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertTrue(register.isOverlong); assertEquals(942755, register.int32Value); } @@ -296,7 +258,6 @@ void nullableOverlong(Collection buffers) { @WithByteBuf("00 40 81") void nullableNotOverlong(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertFalse(register.isOverlong); assertEquals(8192, register.int32Value); } @@ -304,7 +265,6 @@ void nullableNotOverlong(Collection buffers) { @WithByteBuf("7f 7c 1b 1b 9d") void nullableOverlongNegative(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertTrue(register.isOverlong); assertEquals(-7942755, register.int32Value); } @@ -312,7 +272,6 @@ void nullableOverlongNegative(Collection buffers) { @WithByteBuf("7f 3f ff") void nullableNotOverlongNegative(Collection buffers) { decode(nullableInt32Decoder, buffers, register); - assertTrue(nullableInt32Decoder.isReady()); assertFalse(register.isOverlong); assertEquals(-8193, register.int32Value); } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java index e1d2d021..29859de9 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java @@ -36,226 +36,192 @@ class TestInt64 { @WithByteBuf("80") void testNull(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(register.isNull); } @WithByteBuf("81") void optionalZero(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertEquals(0, register.int64Value); } @WithByteBuf("80") void mandatoryZero(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertEquals(0, register.int64Value); } @WithByteBuf("01 00 00 00 00 00 00 00 00 80") void testMaxNullable(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertEquals(Long.MAX_VALUE, register.int64Value); } @WithByteBuf("00 7f 7f 7f 7f 7f 7f 7f 7f ff") void testMaxMandatory(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertEquals(Long.MAX_VALUE, register.int64Value); } @WithByteBuf("7f 00 00 00 00 00 00 00 00 80") void testMinNullable(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertEquals(Long.MIN_VALUE, register.int64Value); } @WithByteBuf("7f 00 00 00 00 00 00 00 00 80") void testMinMandatory(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertEquals(Long.MIN_VALUE, register.int64Value); } @WithByteBuf("01 00 00 00 00 00 00 00 00 81") void testMaxOverflowNullable1(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(register.isOverflow); } @WithByteBuf("01 00 00 00 00 00 00 00 00 00 80") void testMaxOverflowNullable2(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(register.isOverflow); } @WithByteBuf("01 00 00 00 00 00 00 00 00 80") void testMaxOverflowMandatory1(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("00 7f 00 7f 7f 7f 7f 7f 7f 7f ff") void testMaxOverflowMandatory2(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("77 7f 7f 7f 7f 7f 7f 7f 7f ff") void testMinOverflowNullable1(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(register.isOverflow); } @WithByteBuf("7f 00 00 00 00 00 00 00 00 00 80") void testMinOverflowNullable2(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(register.isOverflow); } @WithByteBuf("77 7f 7f 7f 7f 7f 7f 7f 7f ff") void testMinOverflowMandatory1(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("7f 00 00 00 00 00 00 00 00 00 80") void testMinOverflowMandatory2(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertTrue(register.isOverflow); } @WithByteBuf("39 45 a4") void optionalPositive(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertEquals(942755, register.int64Value); } @WithByteBuf("39 45 a3") void mandatoryPositive(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertEquals(942755, register.int64Value); } @WithByteBuf("46 3a dd") void optionalNegative(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertEquals(-942755, register.int64Value); } @WithByteBuf("7c 1b 1b 9d") void mandatoryNegative(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertEquals(-7942755, register.int64Value); } @WithByteBuf("ff") void optionalMinusOne(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertEquals(-1, register.int64Value); } @WithByteBuf("ff") void mandatoryMinusOne(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertEquals(-1, register.int64Value); } @WithByteBuf("00 00 40 82") void optionalSignExtensionPositive(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertEquals(8193, register.int64Value); } @WithByteBuf("00 00 40 81") void mandatorySignExtensionPositive(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertEquals(8193, register.int64Value); } @WithByteBuf("7f 3f ff") void optionalSignExtensionNegative(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertEquals(-8193, register.int64Value); } @WithByteBuf("7f 3f ff") void mandatorySignExtensionNegative(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertEquals(-8193, register.int64Value); } @WithByteBuf("7f 3f ff 7f 3f ff") void mandatoryNegativeTwoValuesInRow(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertEquals(-8193, register.int64Value); decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertEquals(-8193, register.int64Value); } @WithByteBuf("00 00 40 81 00 00 40 81") void mandatoryPositiveTwoValuesInRow(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertEquals(8193, register.int64Value); decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertEquals(8193, register.int64Value); } @WithByteBuf("7f 3f ff 7f 3f ff") void optionalNegativeTwoValuesInRow(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertEquals(-8193, register.int64Value); decode(nullableInt64Decoder, buffers, register); - assertEquals(-8193, register.int64Value); } @WithByteBuf("00 00 40 82 00 00 40 82") void optionalPositiveTwoValuesInRow(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertEquals(8193, register.int64Value); decode(nullableInt64Decoder, buffers, register); - assertEquals(8193, register.int64Value); } @WithByteBuf("00 39 45 a4") void mandatoryOverlong(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertTrue(register.isOverlong); assertEquals(942756, register.int64Value); } @@ -263,7 +229,6 @@ void mandatoryOverlong(Collection buffers) { @WithByteBuf("00 40 81") void mandatoryNotOverlong(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertFalse(register.isOverlong); assertEquals(8193, register.int64Value); } @@ -271,7 +236,6 @@ void mandatoryNotOverlong(Collection buffers) { @WithByteBuf("7f 7c 1b 1b 9d") void mandatoryOverlongNegative(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertTrue(register.isOverlong); assertEquals(-7942755, register.int64Value); } @@ -279,7 +243,6 @@ void mandatoryOverlongNegative(Collection buffers) { @WithByteBuf("7f 3f ff") void mandatoryNotOverlongNegative(Collection buffers) { decode(mandatoryInt64Decoder, buffers, register); - assertTrue(mandatoryInt64Decoder.isReady()); assertFalse(register.isOverlong); assertEquals(-8193, register.int64Value); } @@ -287,7 +250,6 @@ void mandatoryNotOverlongNegative(Collection buffers) { @WithByteBuf("00 39 45 a4") void nullableOverlong(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(register.isOverlong); assertEquals(942755, register.int64Value); } @@ -295,7 +257,6 @@ void nullableOverlong(Collection buffers) { @WithByteBuf("00 40 81") void nullableNotOverlong(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertFalse(register.isOverlong); assertEquals(8192, register.int64Value); } @@ -303,7 +264,6 @@ void nullableNotOverlong(Collection buffers) { @WithByteBuf("7f 7c 1b 1b 9d") void nullableOverlongNegative(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertTrue(register.isOverlong); assertEquals(-7942755, register.int64Value); } @@ -311,7 +271,6 @@ void nullableOverlongNegative(Collection buffers) { @WithByteBuf("7f 3f ff") void nullableNotOverlongNegative(Collection buffers) { decode(nullableInt64Decoder, buffers, register); - assertFalse(register.isOverlong); assertEquals(-8193, register.int64Value); } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java index 3b409ac5..02912eb3 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java @@ -36,91 +36,78 @@ class TestUInt32 { @WithByteBuf("80") void testNull(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(register.isNull); } @WithByteBuf("81") void optionalZero(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertEquals(0, register.uInt32Value); } @WithByteBuf("80") void mandatoryZero(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertEquals(0, register.uInt32Value); } @WithByteBuf("10 00 00 00 80") void testMaxNullable(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertEquals(4294967295L, register.uInt32Value); } @WithByteBuf("0f 7f 7f 7f ff") void testMaxMandatory(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertEquals(4294967295L, register.uInt32Value); } @WithByteBuf("10 00 00 00 81") void testMaxOverflowNullable1(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(register.isOverflow); } @WithByteBuf("10 00 00 00 00 00 80") void testMaxOverflowNullable2(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(register.isOverflow); } @WithByteBuf("10 00 00 00 80") void testMaxOverflowMandatory1(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(register.isOverflow); } @WithByteBuf("0f 7f 7f 7f 7f 00 ff") void testMaxOverflowMandatory2(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(register.isOverflow); } @WithByteBuf("39 45 a4") void optionalSimpleNumber(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertEquals(942755, register.uInt32Value); } @WithByteBuf("0f 7f 7f 7f ff") void optionalSimpleNumber2(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertEquals(4294967294L, register.uInt32Value); } @WithByteBuf("39 45 a3") void mandatorySimpleNumber(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertEquals(942755, register.uInt32Value); } @WithByteBuf("39 45 a4") void optionalSimpleNumberGetValueTwice(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertEquals(942755, register.uInt32Value); assertEquals(942755, register.uInt32Value); } @@ -128,7 +115,6 @@ void optionalSimpleNumberGetValueTwice(Collection buffers) { @WithByteBuf("39 45 a3") void mandatorySimpleNumberGetValueTwice(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertEquals(942755, register.uInt32Value); assertEquals(942755, register.uInt32Value); } @@ -136,29 +122,24 @@ void mandatorySimpleNumberGetValueTwice(Collection buffers) { @WithByteBuf("39 45 a4 0f 7f 7f 7f ff") void optionalSimpleNumbersTwoValuesInRow(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertEquals(942755, register.uInt32Value); decode(nullableUInt32Decoder, buffers, register); - assertEquals(4294967294L, register.uInt32Value); } @WithByteBuf("39 45 a3 39 45 a3") void mandatorySimpleNumbersTwoValuesInRow(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertEquals(942755, register.uInt32Value); decode(mandatoryUInt32Decoder, buffers, register); - assertEquals(942755, register.uInt32Value); } @WithByteBuf("00 39 45 a4") void mandatoryOverlong(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(register.isOverlong); assertEquals(942756, register.uInt32Value); } @@ -166,7 +147,6 @@ void mandatoryOverlong(Collection buffers) { @WithByteBuf("00 40 81") void mandatoryNotOverlong(Collection buffers) { decode(mandatoryUInt32Decoder, buffers, register); - assertFalse(register.isOverlong); assertEquals(8193, register.uInt32Value); } @@ -174,7 +154,6 @@ void mandatoryNotOverlong(Collection buffers) { @WithByteBuf("00 39 45 a4") void nullableOverlong(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertTrue(register.isOverlong); assertEquals(942755, register.uInt32Value); } @@ -182,7 +161,6 @@ void nullableOverlong(Collection buffers) { @WithByteBuf("00 40 81") void nullableNotOverlong(Collection buffers) { decode(nullableUInt32Decoder, buffers, register); - assertFalse(register.isOverlong); assertEquals(8192, register.uInt32Value); } diff --git a/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java b/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java index a06b3367..b09108f2 100644 --- a/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java +++ b/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java @@ -37,70 +37,60 @@ class TestDecodeByteVector { @WithByteBuf("80") void testNull(Collection buffers) { decode(nullableByteVectorDecoder, buffers, register); - assertNull(register.byteVectorValue); } @WithByteBuf("81") void testNullableZeroLen(Collection buffers) { decode(nullableByteVectorDecoder, buffers, register); - assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("80") void testMandatoryZeroLen(Collection buffers) { decode(mandatoryByteVectorDecoder, buffers, register); - assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("10 00 00 00 81 41 42 42 43 44 45") void testNullableLengthOverflow1(Collection buffers) { decode(nullableByteVectorDecoder, buffers, register); - assertTrue(register.isOverflow); } @WithByteBuf("10 00 00 00 00 00 80 41 42 42 43 44 45") void testNullableLengthOverflow2(Collection buffers) { decode(nullableByteVectorDecoder, buffers, register); - assertTrue(register.isOverflow); } @WithByteBuf("10 00 00 00 80 41 42 42 43 44 45") void testMandatoryLengthOverflow1(Collection buffers) { decode(mandatoryByteVectorDecoder, buffers, register); - assertTrue(register.isOverflow); } @WithByteBuf("0f 7f 7f 7f 7f 00 ff 41 42 42 43 44 45") void testMandatoryLengthOverflow2(Collection buffers) { decode(mandatoryByteVectorDecoder, buffers, register); - assertTrue(register.isOverflow); } @WithByteBuf("87 41 42 42 43 44 45") void testSimpleNullableVector(Collection buffers) { decode(nullableByteVectorDecoder, buffers, register); - assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("86 41 42 42 43 44 45") void testSimpleMandatoryVector(Collection buffers) { decode(mandatoryByteVectorDecoder, buffers, register); - assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("81") void testNullableZeroLenGetValueTwice(Collection buffers) { decode(nullableByteVectorDecoder, buffers, register); - assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @@ -108,7 +98,6 @@ void testNullableZeroLenGetValueTwice(Collection buffers) { @WithByteBuf("80") void testMandatoryZeroLenGetValueTwice(Collection buffers) { decode(mandatoryByteVectorDecoder, buffers, register); - assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @@ -116,22 +105,18 @@ void testMandatoryZeroLenGetValueTwice(Collection buffers) { @WithByteBuf("87 41 42 42 43 44 45 81") void testSimpleNullableVectorTwoValuesInRow(Collection buffers) { decode(nullableByteVectorDecoder, buffers, register); - assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); decode(nullableByteVectorDecoder, buffers, register); - assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("86 41 42 42 43 44 45 80") void testSimpleMandatoryVectorTwoValuesInRow(Collection buffers) { decode(mandatoryByteVectorDecoder, buffers, register); - assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); decode(mandatoryByteVectorDecoder, buffers, register); - assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); } } From a2f5d02d272472a288cfee14614f93138885a9e9 Mon Sep 17 00:00:00 2001 From: vdonadze Date: Thu, 6 Aug 2020 13:21:37 +0400 Subject: [PATCH 09/20] simplified Decimal and ByteVector decode methods --- .../epfast/decoder/decimal/DecodeDecimal.java | 5 -- .../decimal/DecodeMandatoryDecimal.java | 71 +++-------------- .../decimal/DecodeNullableDecimal.java | 76 +++---------------- .../integer/DecodeMandatoryUInt64.java | 1 - .../decoder/integer/DecodeNullableUInt64.java | 1 - .../decoder/unicode/DecodeByteVector.java | 2 - .../unicode/DecodeMandatoryByteVector.java | 60 +++++---------- .../unicode/DecodeNullableByteVector.java | 60 +++++---------- 8 files changed, 60 insertions(+), 216 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java index 8554ba4d..2adecbc7 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java @@ -28,8 +28,6 @@ public abstract class DecodeDecimal implements IDecodeContext { boolean exponentReady; - boolean startedMantissa; - boolean ready; boolean exponentOverflow; @@ -40,11 +38,8 @@ public abstract class DecodeDecimal implements IDecodeContext { boolean mantissaOverlong; - protected boolean inProgress; - public final void reset() { exponentReady = false; - startedMantissa = false; ready = false; exponentOverflow = false; mantissaOverflow = false; diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java index aa6cc20b..ab099669 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java @@ -30,8 +30,7 @@ public final class DecodeMandatoryDecimal extends DecodeDecimal { @Override public int decode(ByteBuf buf, UnionRegister register) { - if (!inProgress) { - inProgress = true; + if (!exponentReady) { if (exponentDecoder.decode(buf, register) == FINISHED) { exponentReady = true; if (register.isOverlong) { @@ -43,7 +42,6 @@ public int decode(ByteBuf buf, UnionRegister register) { exponent = register.int32Value; } if (buf.isReadable()) { - startedMantissa = true; if (mantissaDecoder.decode(buf, register) == FINISHED) { ready = true; if (register.isOverlong) { @@ -54,73 +52,28 @@ public int decode(ByteBuf buf, UnionRegister register) { } else { mantissa = register.int64Value; } + setResult(register); + return FINISHED; } } } - } else { - if (exponentReady && startedMantissa) { - if (mantissaDecoder.decode(buf, register) == FINISHED) { - ready = true; - if (register.isOverlong) { - mantissaOverlong = true; - } - if (register.isOverflow) { - mantissaOverflow = true; - } else { - mantissa = register.int64Value; - } - } - } else if (exponentReady) { - startedMantissa = true; - if (mantissaDecoder.decode(buf, register) == FINISHED) { - ready = true; - if (register.isOverlong) { - mantissaOverlong = true; - } - if (register.isOverflow) { - mantissaOverflow = true; - } else { - mantissa = register.int64Value; - } - } + } else if (mantissaDecoder.decode(buf, register) == FINISHED) { + ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } + if (register.isOverflow) { + mantissaOverflow = true; } else { - if (exponentDecoder.decode(buf, register) == FINISHED) { - exponentReady = true; - if (register.isOverlong) { - exponentOverlong = true; - } - if (register.isOverflow) { - exponentOverflow = true; - } else { - exponent = register.int32Value; - } - if (buf.isReadable()) { - startedMantissa = true; - if (mantissaDecoder.decode(buf, register) == FINISHED) { - ready = true; - if (register.isOverlong) { - mantissaOverlong = true; - } - if (register.isOverflow) { - mantissaOverflow = true; - } else { - mantissa = register.int64Value; - } - } - } - } + mantissa = register.int64Value; } - } - if (ready) { setResult(register); return FINISHED; - } else { - return MORE_DATA_NEEDED; } + return MORE_DATA_NEEDED; } public void setResult(UnionRegister register) { - inProgress = false; register.isOverlong = exponentOverlong || mantissaOverlong; if (exponentOverflow) { register.isOverflow = true; diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java index 53fe27c9..4f8c0f5b 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java @@ -32,8 +32,7 @@ public final class DecodeNullableDecimal extends DecodeDecimal { @Override public int decode(ByteBuf buf, UnionRegister register) { - if (!inProgress) { - inProgress = true; + if (!exponentReady) { if (exponentDecoder.decode(buf, register) == FINISHED) { exponentReady = true; if (register.isOverlong) { @@ -45,7 +44,6 @@ public int decode(ByteBuf buf, UnionRegister register) { exponent = register.int32Value; } if (!register.isNull && buf.isReadable()) { - startedMantissa = true; if (mantissaDecoder.decode(buf, register) == FINISHED) { ready = true; if (register.isOverlong) { @@ -56,6 +54,8 @@ public int decode(ByteBuf buf, UnionRegister register) { } else { mantissa = register.int64Value; } + setResult(register); + return FINISHED; } } else if (register.isNull) { nullValue = true; @@ -64,76 +64,24 @@ public int decode(ByteBuf buf, UnionRegister register) { return FINISHED; } } - } else { - if (exponentReady && startedMantissa) { - if (mantissaDecoder.decode(buf, register) == FINISHED) { - ready = true; - if (register.isOverlong) { - mantissaOverlong = true; - } - if (register.isOverflow) { - mantissaOverflow = true; - } else { - mantissa = register.int64Value; - } - } - } else if (exponentReady) { - startedMantissa = true; - if (mantissaDecoder.decode(buf, register) == FINISHED) { - ready = true; - if (register.isOverlong) { - mantissaOverlong = true; - } - if (register.isOverflow) { - mantissaOverflow = true; - } else { - mantissa = register.int64Value; - } - } + } else if (mantissaDecoder.decode(buf, register) == FINISHED) { + ready = true; + if (register.isOverlong) { + mantissaOverlong = true; + } + if (register.isOverflow) { + mantissaOverflow = true; } else { - if (exponentDecoder.decode(buf, register) == FINISHED) { - exponentReady = true; - if (register.isOverlong) { - exponentOverlong = true; - } - if (register.isOverflow) { - exponentOverflow = true; - } else { - exponent = register.int32Value; - } - if (!register.isNull && buf.isReadable()) { - startedMantissa = true; - if (mantissaDecoder.decode(buf, register) == FINISHED) { - ready = true; - if (register.isOverlong) { - mantissaOverlong = true; - } - if (register.isOverflow) { - mantissaOverflow = true; - } else { - mantissa = register.int64Value; - } - } - } else if (register.isNull) { - nullValue = true; - ready = true; - setResult(register); - return FINISHED; - } - } + mantissa = register.int64Value; } - } - if (ready) { setResult(register); return FINISHED; - } else { - return MORE_DATA_NEEDED; } + return MORE_DATA_NEEDED; } @Override public void setResult(UnionRegister register) { - inProgress = false; register.isOverlong = exponentOverlong || mantissaOverlong; if (exponentOverflow) { register.isOverflow = true; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java index d4794652..da42ade9 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java @@ -36,7 +36,6 @@ public int decode(ByteBuf buf, UnionRegister register) { if (!inProgress) { value = 0; inProgress = true; - int oneByte = buf.getByte(readerIndex++); accumulate(oneByte); if (oneByte < 0) { diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java index 06c862d5..75d8528e 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java @@ -36,7 +36,6 @@ public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readLimit = buf.writerIndex(); if (!inProgress) { - value = 0; isUInt64Limit = false; inProgress = true; diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java index c4945662..8d95ebf1 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java @@ -34,8 +34,6 @@ public abstract class DecodeByteVector implements IDecodeContext { boolean overflow; - protected boolean inProgress; - public abstract void setResult(UnionRegister register); public final void reset() { diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java index 2bcaa750..21ed0d40 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java @@ -28,8 +28,7 @@ public final class DecodeMandatoryByteVector extends DecodeByteVector { @Override public int decode(ByteBuf buf, UnionRegister register) { - if (!inProgress) { - inProgress = true; + if (!lengthReady) { if (lengthDecoder.decode(buf, register) == FINISHED) { lengthReady = true; if (register.isOverflow) { @@ -47,63 +46,40 @@ public int decode(ByteBuf buf, UnionRegister register) { } if (counter == messageLength) { ready = true; + buf.readerIndex(readerIndex); + setResult(register); + return FINISHED; } } buf.readerIndex(readerIndex); } else { ready = true; + setResult(register); + return FINISHED; } } } else { - if (lengthReady) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - while ((readerIndex < readLimit) && !ready) { - if (counter < messageLength) { - value.add(buf.getByte(readerIndex++)); - counter++; - } - if (counter == messageLength) { - ready = true; - } + int readerIndex = buf.readerIndex(); + int readLimit = buf.writerIndex(); + while ((readerIndex < readLimit) && !ready) { + if (counter < messageLength) { + value.add(buf.getByte(readerIndex++)); + counter++; } - buf.readerIndex(readerIndex); - } else if (lengthDecoder.decode(buf, register) == FINISHED) { - lengthReady = true; - if (register.isOverflow) { - overflow = true; - } else { - messageLength = register.uInt32Value; - } - if (messageLength > 0) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - while ((readerIndex < readLimit) && !ready) { - if (counter < messageLength) { - value.add(buf.getByte(readerIndex++)); - counter++; - } - if (counter == messageLength) { - ready = true; - } - } - buf.readerIndex(readerIndex); - } else { + if (counter == messageLength) { ready = true; + buf.readerIndex(readerIndex); + setResult(register); + return FINISHED; } } + buf.readerIndex(readerIndex); } - if (ready) { - setResult(register); - return FINISHED; - } else { - return MORE_DATA_NEEDED; - } + return MORE_DATA_NEEDED; } @Override public void setResult(UnionRegister register) { - inProgress = false; if (overflow) { register.isOverflow = true; register.infoMessage = "length value range is uint32"; diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java index 12eed12f..867b55e8 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java @@ -28,8 +28,7 @@ public final class DecodeNullableByteVector extends DecodeByteVector { @Override public int decode(ByteBuf buf, UnionRegister register) { - if (!inProgress) { - inProgress = true; + if (!lengthReady) { if (lengthDecoder.decode(buf, register) == FINISHED) { lengthReady = true; if (register.isOverflow) { @@ -47,63 +46,40 @@ public int decode(ByteBuf buf, UnionRegister register) { } if (counter == messageLength) { ready = true; + buf.readerIndex(readerIndex); + setResult(register); + return FINISHED; } } buf.readerIndex(readerIndex); } else { ready = true; + setResult(register); + return FINISHED; } } } else { - if (lengthReady) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - while ((readerIndex < readLimit) && !ready) { - if (counter < messageLength) { - value.add(buf.getByte(readerIndex++)); - counter++; - } - if (counter == messageLength) { - ready = true; - } + int readerIndex = buf.readerIndex(); + int readLimit = buf.writerIndex(); + while ((readerIndex < readLimit) && !ready) { + if (counter < messageLength) { + value.add(buf.getByte(readerIndex++)); + counter++; } - buf.readerIndex(readerIndex); - } else if (lengthDecoder.decode(buf, register) == FINISHED) { - lengthReady = true; - if (register.isOverflow) { - overflow = true; - } else { - messageLength = register.uInt32Value; - } - if (!register.isNull && messageLength > 0) { - int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - while ((readerIndex < readLimit) && !ready) { - if (counter < messageLength) { - value.add(buf.getByte(readerIndex++)); - counter++; - } - if (counter == messageLength) { - ready = true; - } - } - buf.readerIndex(readerIndex); - } else { + if (counter == messageLength) { ready = true; + buf.readerIndex(readerIndex); + setResult(register); + return FINISHED; } } + buf.readerIndex(readerIndex); } - if (ready) { - setResult(register); - return FINISHED; - } else { - return MORE_DATA_NEEDED; - } + return MORE_DATA_NEEDED; } @Override public void setResult(UnionRegister register) { - inProgress = false; if (overflow) { register.isOverflow = true; register.infoMessage = "length value range is uint32"; From 1c5f516e75dd49b8d37b6c0abebd850c43566970 Mon Sep 17 00:00:00 2001 From: vdonadze Date: Fri, 7 Aug 2020 16:12:38 +0400 Subject: [PATCH 10/20] refactored tests to check register flags --- .../ascii/DecodeMandatoryAsciiString.java | 4 +- .../ascii/DecodeNullableAsciiString.java | 6 +- .../decimal/DecodeMandatoryDecimal.java | 3 + .../decimal/DecodeNullableDecimal.java | 3 + .../epfast/decoder/integer/DecodeInteger.java | 3 + .../decoder/integer/DecodeMandatoryInt32.java | 17 +- .../decoder/integer/DecodeMandatoryInt64.java | 17 +- .../integer/DecodeMandatoryUInt32.java | 10 +- .../integer/DecodeMandatoryUInt64.java | 12 +- .../decoder/integer/DecodeNullableInt32.java | 17 +- .../decoder/integer/DecodeNullableInt64.java | 17 +- .../decoder/integer/DecodeNullableUInt32.java | 10 +- .../decoder/integer/DecodeNullableUInt64.java | 13 +- .../epfast/decoder/message/UnionRegister.java | 2 +- .../presencemap/DecodePresenceMap.java | 1 + .../unicode/DecodeMandatoryByteVector.java | 1 + .../unicode/DecodeNullableByteVector.java | 1 + .../decoder/ascii/TestDecodeAsciiString.java | 50 ++- .../decoder/decimal/TestDecodeDecimal.java | 294 +++++++++++----- .../epfast/decoder/integer/TestInt32.java | 319 ++++++++++++----- .../epfast/decoder/integer/TestInt64.java | 323 +++++++++++++----- .../epfast/decoder/integer/TestUInt32.java | 184 +++++++--- .../epfast/decoder/integer/TestUInt64.java | 190 ++++++++--- .../presencemap/TestDecodePresenceMap.java | 69 ++-- .../decoder/unicode/TestDecodeByteVector.java | 112 ++++-- 25 files changed, 1171 insertions(+), 507 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java index 391004fd..86962732 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java @@ -32,8 +32,11 @@ public DecodeMandatoryAsciiString(boolean checkOverlong) { public void setResult(UnionRegister register) { if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { register.isOverflow = true; + register.isOverlong = false; + register.isNull = false; register.infoMessage = "String is longer than allowed"; } else if (zeroCount < stringBuilder.length()) { + register.isNull = false; if ((zeroCount > 1) && checkOverlong) { register.isOverflow = false; register.isOverlong = false; @@ -46,7 +49,6 @@ public void setResult(UnionRegister register) { } else { register.isOverflow = false; register.isOverlong = false; - register.isNull = false; register.stringValue = stringBuilder.toString(); } } else { diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java index 54421c36..e46587a2 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java @@ -32,8 +32,11 @@ public DecodeNullableAsciiString(boolean checkOverlong) { public void setResult(UnionRegister register) { if (stringBuilder.length() >= MAX_ALLOWED_LENGTH) { register.isOverflow = true; + register.isOverlong = false; + register.isNull = false; register.infoMessage = "String is longer than allowed"; } else if (zeroCount < stringBuilder.length()) { + register.isNull = false; if ((zeroCount > 2) && checkOverlong) { register.isOverflow = false; register.isOverlong = false; @@ -50,7 +53,7 @@ public void setResult(UnionRegister register) { register.stringValue = stringBuilder.substring(2); } else { register.isOverflow = false; - register.isNull = false; + register.isOverlong = false; register.stringValue = stringBuilder.toString(); } } else if (zeroCount == 1) { @@ -61,6 +64,7 @@ public void setResult(UnionRegister register) { } else { stringBuilder.setLength(zeroCount - 2); register.isOverflow = false; + register.isOverlong = false; register.isNull = false; register.stringValue = stringBuilder.toString(); } diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java index ab099669..4c8f18b2 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java @@ -77,9 +77,11 @@ public void setResult(UnionRegister register) { register.isOverlong = exponentOverlong || mantissaOverlong; if (exponentOverflow) { register.isOverflow = true; + register.isNull = false; register.infoMessage = "exponent value range is int32"; } else if (mantissaOverflow) { register.isOverflow = true; + register.isNull = false; register.infoMessage = "mantissa value range is int64"; } else if (exponent >= -63 && exponent <= 63) { register.isOverflow = false; @@ -87,6 +89,7 @@ public void setResult(UnionRegister register) { register.decimalValue = new BigDecimal(mantissa).movePointRight(exponent); } else { register.isOverflow = true; + register.isNull = false; register.infoMessage = "exponent value allowed range is -63 ... 63"; } reset(); diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java index 4f8c0f5b..5308af96 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java @@ -85,9 +85,11 @@ public void setResult(UnionRegister register) { register.isOverlong = exponentOverlong || mantissaOverlong; if (exponentOverflow) { register.isOverflow = true; + register.isNull = false; register.infoMessage = "exponent value range is int32"; } else if (mantissaOverflow) { register.isOverflow = true; + register.isNull = false; register.infoMessage = "mantissa value range is int64"; } else if (nullValue) { register.isOverflow = false; @@ -98,6 +100,7 @@ public void setResult(UnionRegister register) { register.decimalValue = new BigDecimal(mantissa).movePointRight(exponent); } else { register.isOverflow = true; + register.isNull = false; register.infoMessage = "exponent value allowed range is -63 ... 63"; } reset(); diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java index d2ddfee6..5bcf934e 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java @@ -27,6 +27,8 @@ public abstract class DecodeInteger implements IDecodeContext { protected boolean overflow; + protected boolean overlong; + boolean checkForSignExtension = false; protected boolean inProgress; @@ -34,6 +36,7 @@ public abstract class DecodeInteger implements IDecodeContext { protected final void reset() { ready = false; overflow = false; + overlong = false; checkForSignExtension = false; } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java index 66704e09..6d19de83 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java @@ -43,7 +43,7 @@ public int decode(ByteBuf buf, UnionRegister register) { return FINISHED; } if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte + checkOverlongPositive(buf.getByte(readerIndex)); //check second byte do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -59,7 +59,7 @@ public int decode(ByteBuf buf, UnionRegister register) { return FINISHED; } if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte + checkOverlongNegative(buf.getByte(readerIndex)); //check second byte do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -70,7 +70,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } else { if (value >= 0) { if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking + checkOverlongPositive(buf.getByte(readerIndex)); //continue checking checkForSignExtension = false; } do { @@ -78,7 +78,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } while (!ready && readerIndex < readLimit); } else { if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes + checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes checkForSignExtension = false; } do { @@ -98,6 +98,7 @@ public int decode(ByteBuf buf, UnionRegister register) { @Override public void setResult(UnionRegister register) { inProgress = false; + register.isOverlong = overlong; if (overflow) { register.isOverflow = true; register.infoMessage = "Int32 Overflow"; @@ -133,11 +134,11 @@ private void accumulateNegative(int oneByte) { } } - private void checkOverlongPositive(int secondByte, UnionRegister register) { - register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlongPositive(int secondByte) { + overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } - private void checkOverlongNegative(int secondByte, UnionRegister register) { - register.isOverlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); + private void checkOverlongNegative(int secondByte) { + overlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java index 693d4a02..7714d7f9 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java @@ -43,7 +43,7 @@ public int decode(ByteBuf buf, UnionRegister register) { return FINISHED; } if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte + checkOverlongPositive(buf.getByte(readerIndex)); //check second byte do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -59,7 +59,7 @@ public int decode(ByteBuf buf, UnionRegister register) { return FINISHED; } if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte + checkOverlongNegative(buf.getByte(readerIndex)); //check second byte do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -70,7 +70,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } else { if (value >= 0) { if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking + checkOverlongPositive(buf.getByte(readerIndex)); //continue checking checkForSignExtension = false; } do { @@ -78,7 +78,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } while (!ready && readerIndex < readLimit); } else { if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes + checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes checkForSignExtension = false; } do { @@ -98,6 +98,7 @@ public int decode(ByteBuf buf, UnionRegister register) { @Override public void setResult(UnionRegister register) { inProgress = false; + register.isOverlong = overlong; if (overflow) { register.isOverflow = true; register.infoMessage = "Int64 Overflow"; @@ -133,11 +134,11 @@ private void accumulateNegative(int oneByte) { } } - private void checkOverlongPositive(int secondByte, UnionRegister register) { - register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlongPositive(int secondByte) { + overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } - private void checkOverlongNegative(int secondByte, UnionRegister register) { - register.isOverlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); + private void checkOverlongNegative(int secondByte) { + overlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java index 5a2363c5..a197e083 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java @@ -40,7 +40,7 @@ public int decode(ByteBuf buf, UnionRegister register) { return FINISHED; } if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex), register); //check second byte + checkOverlong(buf.getByte(readerIndex)); //check second byte do { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -49,7 +49,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } } else { if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex), register); //continue checking + checkOverlong(buf.getByte(readerIndex)); //continue checking checkForSignExtension = false; } do { @@ -68,8 +68,10 @@ public int decode(ByteBuf buf, UnionRegister register) { @Override public void setResult(UnionRegister register) { inProgress = false; + register.isOverlong = overlong; if (overflow) { register.isOverflow = true; + register.isNull = false; register.infoMessage = "UInt32 Overflow"; } else { register.isOverflow = false; @@ -91,7 +93,7 @@ private void accumulate(int oneByte) { } } - private void checkOverlong(int secondByte, UnionRegister register) { - register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlong(int secondByte) { + overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java index da42ade9..1a9d8a83 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java @@ -44,7 +44,7 @@ public int decode(ByteBuf buf, UnionRegister register) { return FINISHED; } if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex), register); //check second byte + checkOverlong(buf.getByte(readerIndex)); //check second byte do { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -53,7 +53,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } } else { if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex), register); //continue checking + checkOverlong(buf.getByte(readerIndex)); //continue checking checkForSignExtension = false; } do { @@ -72,14 +72,16 @@ public int decode(ByteBuf buf, UnionRegister register) { @Override public void setResult(UnionRegister register) { inProgress = false; + register.isOverlong = overlong; if (overflow) { register.isOverflow = true; + register.isNull = false; register.infoMessage = "UInt32 Overflow"; } else { longToBytes(value, bytes); register.isOverflow = false; register.isNull = false; - register.unsignedInt64Value = new BigInteger(1, bytes); + register.uInt64Value = new BigInteger(1, bytes); } reset(); } @@ -96,8 +98,8 @@ private void accumulate(int oneByte) { } } - private void checkOverlong(int secondByte, UnionRegister register) { - register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlong(int secondByte) { + overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java index 39d95ee8..aa1d110d 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java @@ -46,7 +46,7 @@ public int decode(ByteBuf buf, UnionRegister register) { return FINISHED; } if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte + checkOverlongPositive(buf.getByte(readerIndex)); //check second byte do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -63,7 +63,7 @@ public int decode(ByteBuf buf, UnionRegister register) { return FINISHED; } if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte + checkOverlongNegative(buf.getByte(readerIndex)); //check second byte do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -74,7 +74,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } else { if (value >= 0) { if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking + checkOverlongPositive(buf.getByte(readerIndex)); //continue checking checkForSignExtension = false; } do { @@ -82,7 +82,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } while (!ready && readerIndex < readLimit); } else { if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes + checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes checkForSignExtension = false; } do { @@ -102,6 +102,7 @@ public int decode(ByteBuf buf, UnionRegister register) { @Override public void setResult(UnionRegister register) { inProgress = false; + register.isOverlong = overlong; if (overflow) { register.isOverflow = true; register.infoMessage = "Int32 Overflow"; @@ -143,11 +144,11 @@ private void accumulateNegative(int oneByte) { } } - private void checkOverlongPositive(int secondByte, UnionRegister register) { - register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlongPositive(int secondByte) { + overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } - private void checkOverlongNegative(int secondByte, UnionRegister register) { - register.isOverlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); + private void checkOverlongNegative(int secondByte) { + overlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java index b835c89b..4779ab2a 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java @@ -46,7 +46,7 @@ public int decode(ByteBuf buf, UnionRegister register) { return FINISHED; } if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex), register); //check second byte + checkOverlongPositive(buf.getByte(readerIndex)); //check second byte do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -63,7 +63,7 @@ public int decode(ByteBuf buf, UnionRegister register) { return FINISHED; } if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check second byte + checkOverlongNegative(buf.getByte(readerIndex)); //check second byte do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -74,7 +74,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } else { if (value >= 0) { if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex), register); //continue checking + checkOverlongPositive(buf.getByte(readerIndex)); //continue checking checkForSignExtension = false; } do { @@ -82,7 +82,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } while (!ready && readerIndex < readLimit); } else { if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex), register); //check first and second bytes + checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes checkForSignExtension = false; } do { @@ -102,6 +102,7 @@ public int decode(ByteBuf buf, UnionRegister register) { @Override public void setResult(UnionRegister register) { inProgress = false; + register.isOverlong = overlong; if (overflow) { register.isOverflow = true; register.infoMessage = "Int64 Overflow"; @@ -143,11 +144,11 @@ private void accumulateNegative(int oneByte) { } } - private void checkOverlongPositive(int secondByte, UnionRegister register) { - register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlongPositive(int secondByte) { + overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } - private void checkOverlongNegative(int secondByte, UnionRegister register) { - register.isOverlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); + private void checkOverlongNegative(int secondByte) { + overlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java index 1bb7b0c3..dc1e89fe 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java @@ -43,7 +43,7 @@ public int decode(ByteBuf buf, UnionRegister register) { return FINISHED; } if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex), register); //check second byte + checkOverlong(buf.getByte(readerIndex)); //check second byte do { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -52,7 +52,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } } else { if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex), register); //continue checking + checkOverlong(buf.getByte(readerIndex)); //continue checking checkForSignExtension = false; } do { @@ -71,8 +71,10 @@ public int decode(ByteBuf buf, UnionRegister register) { @Override public void setResult(UnionRegister register) { inProgress = false; + register.isOverlong = overlong; if (overflow) { register.isOverflow = true; + register.isNull = false; register.infoMessage = "UInt32 Overflow"; } else if (value == 0) { register.isOverflow = false; @@ -99,7 +101,7 @@ private void accumulate(int oneByte) { } } - private void checkOverlong(int secondByte, UnionRegister register) { - register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlong(int secondByte) { + overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java index 75d8528e..a50f9328 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java @@ -48,7 +48,7 @@ public int decode(ByteBuf buf, UnionRegister register) { return FINISHED; } if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex), register); //check second byte + checkOverlong(buf.getByte(readerIndex)); //check second byte do { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); @@ -57,7 +57,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } } else { if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex), register); //continue checking + checkOverlong(buf.getByte(readerIndex)); //continue checking checkForSignExtension = false; } do { @@ -76,12 +76,15 @@ public int decode(ByteBuf buf, UnionRegister register) { @Override public void setResult(UnionRegister register) { inProgress = false; + register.isOverlong = overlong; if (overflow) { register.isOverflow = true; + register.isNull = false; register.infoMessage = "UInt64 Overflow"; } else if (value == 0) { register.isOverflow = false; register.isNull = true; + register.uInt64Value = null; } else { register.isOverflow = false; register.isNull = false; @@ -90,7 +93,7 @@ public void setResult(UnionRegister register) { } else { longToBytes(value - 1, bytes); } - register.unsignedInt64Value = new BigInteger(1, bytes); + register.uInt64Value = new BigInteger(1, bytes); } reset(); } @@ -109,7 +112,7 @@ private void accumulate(int oneByte) { } } - private void checkOverlong(int secondByte, UnionRegister register) { - register.isOverlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + private void checkOverlong(int secondByte) { + overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java b/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java index 29cc435a..3070a19f 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/UnionRegister.java @@ -38,7 +38,7 @@ public class UnionRegister { public long int64Value; - public BigInteger unsignedInt64Value; + public BigInteger uInt64Value; public BigDecimal decimalValue; diff --git a/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java b/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java index 8a8e5d2e..720c8836 100644 --- a/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java +++ b/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java @@ -51,6 +51,7 @@ public int decode(ByteBuf buf, UnionRegister register) { public void setResult(UnionRegister register) { register.isOverlong = setIndex > lastNonZeroIndex; + register.isNull = false; register.presenceMap = new PresenceMap((BitSet) value.clone()); } diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java index 21ed0d40..0624fd3e 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java @@ -82,6 +82,7 @@ public int decode(ByteBuf buf, UnionRegister register) { public void setResult(UnionRegister register) { if (overflow) { register.isOverflow = true; + register.isNull = false; register.infoMessage = "length value range is uint32"; } else { byte[] finalVal = new byte[value.size()]; diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java index 867b55e8..710cebc3 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java @@ -82,6 +82,7 @@ public int decode(ByteBuf buf, UnionRegister register) { public void setResult(UnionRegister register) { if (overflow) { register.isOverflow = true; + register.isNull = false; register.infoMessage = "length value range is uint32"; } else { byte[] finalVal = new byte[value.size()]; diff --git a/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java b/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java index 66a43aae..821099ab 100644 --- a/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java +++ b/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java @@ -19,6 +19,7 @@ import com.exactpro.epfast.decoder.message.UnionRegister; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -32,7 +33,7 @@ class TestDecodeAsciiString { private final UnionRegister decodeResult = new UnionRegister(); - + static String fastAsciiStringOf(char character, int length) { if (character > 0 && character < 128) { StringBuilder stringBuilder = new StringBuilder(length); @@ -51,17 +52,14 @@ class TestOptional { @WithByteBuf("80") void testNull(Collection buffers) { - decodeResult.isOverflow = true; decodeResult.isNull = false; - decodeResult.isOverlong = true; decodeResult.stringValue = ""; decode(decoder, buffers, decodeResult); - - assertFalse(decodeResult.isOverflow); + assertNull(decodeResult.stringValue); assertTrue(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isOverlong); - assertNull(decodeResult.stringValue); } @WithByteBuf("00 80") @@ -84,6 +82,8 @@ void testOptionalSimpleString(Collection buffers) { @WithByteBuf("00 C1") void testOptionalOverlongString1(Collection buffers) { + decodeResult.isOverlong = false; + decode(decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isNull); @@ -93,6 +93,8 @@ void testOptionalOverlongString1(Collection buffers) { @WithByteBuf("00 00 C1") void testOptionalOverlongString2(Collection buffers) { + decodeResult.isOverlong = false; + decode(decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isNull); @@ -116,13 +118,15 @@ void testOptionalStringDecoderReuse(Collection buffers) { assertFalse(decodeResult.isNull); assertFalse(decodeResult.isOverlong); assertEquals("ABC", decodeResult.stringValue); - + + resetRegisterFlags(); decode(decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isNull); assertFalse(decodeResult.isOverlong); assertEquals("BBC", decodeResult.stringValue); - + + resetRegisterFlags(); decode(decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isNull); @@ -154,15 +158,19 @@ void testOptionalOverlong1(Collection buffers) { @Test void testOptionalOverlong2() { + decodeResult.isOverflow = false; + decoder.decode( fromHex(fastAsciiStringOf(')', 2 * DecodeAsciiString.MAX_ALLOWED_LENGTH)), decodeResult); assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } } @WithByteBuf("00 00 80 00 00 00 00 80") - void testOptionalStringTwoValuesInRow(Collection buffers) { + void testOptionalStringTwoValuesInRow(Collection buffers) { decode(decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isNull); @@ -182,7 +190,7 @@ class TestMandatory { private final DecodeMandatoryAsciiString decoder = new DecodeMandatoryAsciiString(true); @WithByteBuf("80") - void testMandatoryEmptyString(Collection buffers) { + void testMandatoryEmptyString(Collection buffers) { decode(decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isNull); @@ -191,7 +199,7 @@ void testMandatoryEmptyString(Collection buffers) { } @WithByteBuf("00 00 80") - void testMandatoryStringAllZeros1(Collection buffers) { + void testMandatoryStringAllZeros1(Collection buffers) { decode(decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isNull); @@ -200,7 +208,7 @@ void testMandatoryStringAllZeros1(Collection buffers) { } @WithByteBuf("00 00 00 00 80") - void testMandatoryStringAllZeros2(Collection buffers) { + void testMandatoryStringAllZeros2(Collection buffers) { decode(decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isNull); @@ -210,6 +218,8 @@ void testMandatoryStringAllZeros2(Collection buffers) { @WithByteBuf("00 C1") void testMandatoryOverlongString(Collection buffers) { + decodeResult.isOverlong = false; + decode(decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isNull); @@ -232,6 +242,8 @@ class TestOverflowException { @WithByteBuf("00 C1") void testMandatoryOverlong1(Collection buffers) { + decodeResult.isOverlong = false; + decode(decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isNull); @@ -241,15 +253,19 @@ void testMandatoryOverlong1(Collection buffers) { @Test void testMandatoryOverlong2() { + decodeResult.isOverflow = false; + decoder.decode( fromHex(fastAsciiStringOf('*', 3 * DecodeAsciiString.MAX_ALLOWED_LENGTH)), decodeResult); assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } } @WithByteBuf("00 00 80 00 00 00 00 80") - void testMandatoryStringTwoValuesInRow(Collection buffers) { + void testMandatoryStringTwoValuesInRow(Collection buffers) { decode(decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isNull); @@ -263,4 +279,12 @@ void testMandatoryStringTwoValuesInRow(Collection buffers) { assertEquals("\0\0\0\0", decodeResult.stringValue); } } + + @BeforeEach + void resetRegisterFlags() { + decodeResult.isOverlong = true; + decodeResult.isNull = true; + decodeResult.isOverflow = true; + decodeResult.stringValue = null; + } } diff --git a/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java b/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java index 6277c3fa..e10c648a 100644 --- a/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java +++ b/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java @@ -22,9 +22,11 @@ import com.exactpro.epfast.decoder.message.UnionRegister; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; +import org.junit.jupiter.api.BeforeEach; import static org.junit.jupiter.api.Assertions.*; import static com.exactpro.epfast.DecoderUtils.*; +import static org.junit.jupiter.api.Assertions.assertFalse; class TestDecodeDecimal { @@ -32,215 +34,325 @@ class TestDecodeDecimal { private DecodeMandatoryDecimal mandatoryDecimalDecoder = new DecodeMandatoryDecimal(); - private UnionRegister register = new UnionRegister(); + private UnionRegister decodeResult = new UnionRegister(); @WithByteBuf("80") void testNull(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertNull(register.decimalValue); + decodeResult.isNull = false; + decodeResult.decimalValue = new BigDecimal(1); + + decode(nullableDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertTrue(decodeResult.isNull); + assertNull(decodeResult.decimalValue); } @WithByteBuf("83 39 45 a3") void testNullablePositive1(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigDecimal("94275500"), register.decimalValue); + decode(nullableDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); } @WithByteBuf("82 04 3f 34 de") void testNullablePositive(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigDecimal("94275500"), register.decimalValue); + decode(nullableDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); } @WithByteBuf("82 39 45 a3") void testMandatoryPositive(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigDecimal("94275500"), register.decimalValue); + decode(mandatoryDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); } @WithByteBuf("81 04 3f 34 de") void testMandatoryPositive2(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigDecimal("94275500"), register.decimalValue); + decode(mandatoryDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); } @WithByteBuf("fe 39 45 a3") void testMandatoryPositive3(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigDecimal("9427.55"), register.decimalValue); + decode(mandatoryDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("9427.55"), decodeResult.decimalValue); } @WithByteBuf("fe 39 45 a3") void testNullablePositive3(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigDecimal("9427.55"), register.decimalValue); + decode(nullableDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("9427.55"), decodeResult.decimalValue); } @WithByteBuf("fe 46 3a dd") void testNullableNegative(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigDecimal("-9427.55"), register.decimalValue); + decode(nullableDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("-9427.55"), decodeResult.decimalValue); } @WithByteBuf("fd 7f 3f ff") void testNullableNegativeSignExtension(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigDecimal("-8.193"), register.decimalValue); + decode(nullableDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("-8.193"), decodeResult.decimalValue); } @WithByteBuf("39 45 a4 7f 3f ff") void testExponentIOException(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); } @WithByteBuf("82 04 3f 34 de") void testNullablePositiveGetValueTwice(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigDecimal("94275500"), register.decimalValue); - assertEquals(new BigDecimal("94275500"), register.decimalValue); + decode(nullableDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); } @WithByteBuf("82 39 45 a3") void testMandatoryPositiveGetValueTwice(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigDecimal("94275500"), register.decimalValue); - assertEquals(new BigDecimal("94275500"), register.decimalValue); + decode(mandatoryDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); } @WithByteBuf("83 39 45 a3 82 04 3f 34 de") void testNullablePositiveTwoValuesInRow(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigDecimal("94275500"), register.decimalValue); - decode(nullableDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigDecimal("94275500"), register.decimalValue); + decode(nullableDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); + + decode(nullableDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); } @WithByteBuf("82 39 45 a3 81 04 3f 34 de") void testMandatoryPositiveTwoValuesInRow(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigDecimal("94275500"), register.decimalValue); - decode(mandatoryDecimalDecoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigDecimal("94275500"), register.decimalValue); + decode(mandatoryDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); + + decode(mandatoryDecimalDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); } @WithByteBuf("08 00 00 00 81 39 45 a3") void testNullableExponentOverflow1(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); } @WithByteBuf("08 00 00 00 80 39 45 a3") void testMandatoryExponentOverflow1(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); } @WithByteBuf("08 00 00 00 00 81 39 45 a3") void testNullableExponentOverflow2(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); } @WithByteBuf("07 7f 00 7f 7f 7f ff 39 45 a3") void testMandatoryExponentOverflow2(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); } @WithByteBuf("86 01 00 00 00 00 00 00 00 00 80") void testNullableMantissaOverflow1(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); } @WithByteBuf("86 01 00 00 00 00 00 00 00 00 80") void testMandatoryMantissaOverflow1(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); } @WithByteBuf("86 00 7f 00 7f 7f 7f 7f 7f 7f 7f ff") void testNullableMantissaOverflow2(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = true; + + decode(nullableDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); } @WithByteBuf("86 00 7f 00 7f 7f 7f 7f 7f 7f 7f ff") void testMandatoryMantissaOverflow2(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); } @WithByteBuf("00 83 39 45 a3") void testNullableExponentOverlong(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(new BigDecimal("94275500"), register.decimalValue); + decodeResult.isOverlong = false; + + decode(nullableDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); } @WithByteBuf("7f fe 46 3a dd") void testNullableNegativeExponentOverlong(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(new BigDecimal("-9427.55"), register.decimalValue); + decodeResult.isOverlong = false; + + decode(nullableDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("-9427.55"), decodeResult.decimalValue); } @WithByteBuf("00 82 39 45 a3") void testMandatoryExponentOverlong(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(new BigDecimal("94275500"), register.decimalValue); + decodeResult.isOverlong = false; + + decode(mandatoryDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); } @WithByteBuf("7f fe 46 3a dd") void testMandatoryNegativeExponentOverlong(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(new BigDecimal("-9427.55"), register.decimalValue); + decodeResult.isOverlong = false; + + decode(mandatoryDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("-9427.55"), decodeResult.decimalValue); } @WithByteBuf("fe 7f 46 3a dd") void testNullableNegativeMantissaOverlong(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(new BigDecimal("-9427.55"), register.decimalValue); + decodeResult.isOverlong = false; + + decode(nullableDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("-9427.55"), decodeResult.decimalValue); } @WithByteBuf("83 00 39 45 a3") void testNullableMantissaOverlong(Collection buffers) { - decode(nullableDecimalDecoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(new BigDecimal("94275500"), register.decimalValue); + decodeResult.isOverlong = false; + + decode(nullableDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); } @WithByteBuf("82 00 39 45 a3") void testMandatoryMantissaOverlong(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(new BigDecimal("94275500"), register.decimalValue); + decodeResult.isOverlong = false; + + decode(mandatoryDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("94275500"), decodeResult.decimalValue); } @WithByteBuf("fe 7f 46 3a dd") void testMandatoryNegativeMantissaOverlong(Collection buffers) { - decode(mandatoryDecimalDecoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(new BigDecimal("-9427.55"), register.decimalValue); + decodeResult.isOverlong = false; + + decode(mandatoryDecimalDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(new BigDecimal("-9427.55"), decodeResult.decimalValue); + } + + @BeforeEach + void resetRegisterFlags() { + decodeResult.isOverlong = true; + decodeResult.isNull = true; + decodeResult.isOverflow = true; + decodeResult.decimalValue = null; } } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java index 52e2b524..791e79f7 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java @@ -20,6 +20,7 @@ import io.netty.buffer.ByteBuf; import com.exactpro.junit5.WithByteBuf; +import org.junit.jupiter.api.BeforeEach; import java.util.Collection; @@ -32,248 +33,384 @@ class TestInt32 { private DecodeMandatoryInt32 mandatoryInt32Decoder = new DecodeMandatoryInt32(); - private UnionRegister register = new UnionRegister(); + private UnionRegister decodeResult = new UnionRegister(); @WithByteBuf("80") void testNull(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertTrue(register.isNull); + decodeResult.isNull = false; + + decode(nullableInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(decodeResult.int32Value, -999); } @WithByteBuf("81") void optionalZero(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertEquals(0, register.int32Value); + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(0, decodeResult.int32Value); + } @WithByteBuf("80") void mandatoryZero(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertEquals(0, register.int32Value); + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(0, decodeResult.int32Value); } @WithByteBuf("08 00 00 00 80") void testMaxNullable(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertEquals(Integer.MAX_VALUE, register.int32Value); + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(Integer.MAX_VALUE, decodeResult.int32Value); } @WithByteBuf("07 7f 7f 7f ff") void testMaxMandatory(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertEquals(Integer.MAX_VALUE, register.int32Value); + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(Integer.MAX_VALUE, decodeResult.int32Value); } @WithByteBuf("78 00 00 00 80") void testMinNullable(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertEquals(Integer.MIN_VALUE, register.int32Value); + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(Integer.MIN_VALUE, decodeResult.int32Value); } @WithByteBuf("78 00 00 00 80") void testMinMandatory(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertEquals(Integer.MIN_VALUE, register.int32Value); + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(Integer.MIN_VALUE, decodeResult.int32Value); } @WithByteBuf("08 00 00 00 81") void testMaxOverflowNullable1(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertTrue(decodeResult.isOverflow); } @WithByteBuf("08 00 00 00 00 00 00 80") void testMaxOverflowNullable2(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("08 00 00 00 80") void testMaxOverflowMandatory1(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("07 7f 00 7f 7f 7f ff") void testMaxOverflowMandatory2(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("77 7f 7f 7f ff") void testMinOverflowNullable1(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("78 00 00 00 00 80") void testMinOverflowNullable2(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("77 7f 7f 7f ff") void testMinOverflowMandatory1(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("78 00 00 00 00 80") void testMinOverflowMandatory2(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("39 45 a4") void optionalPositive(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertEquals(942755, register.int32Value); + decode(nullableInt32Decoder, buffers, decodeResult); + assertEquals(942755, decodeResult.int32Value); } @WithByteBuf("39 45 a3") void mandatoryPositive(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertEquals(942755, register.int32Value); + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(942755, decodeResult.int32Value); } @WithByteBuf("46 3a dd") void optionalNegative(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertEquals(-942755, register.int32Value); + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(-942755, decodeResult.int32Value); } @WithByteBuf("7c 1b 1b 9d") void mandatoryNegative(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertEquals(-7942755, register.int32Value); + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(-7942755, decodeResult.int32Value); } @WithByteBuf("ff") void optionalMinusOne(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertEquals(-1, register.int32Value); + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(-1, decodeResult.int32Value); } @WithByteBuf("ff") void mandatoryMinusOne(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertEquals(-1, register.int32Value); + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(-1, decodeResult.int32Value); } @WithByteBuf("00 00 40 82") void optionalSignExtensionPositive(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertEquals(8193, register.int32Value); + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int32Value); } @WithByteBuf("00 00 40 81") void mandatorySignExtensionPositive(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertEquals(8193, register.int32Value); + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int32Value); } @WithByteBuf("7f 3f ff") void optionalSignExtensionNegative(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertEquals(-8193, register.int32Value); + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(-8193, decodeResult.int32Value); } @WithByteBuf("7f 3f ff") void mandatorySignExtensionNegative(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertEquals(-8193, register.int32Value); + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(-8193, decodeResult.int32Value); } @WithByteBuf("7f 3f ff 7f 3f ff") void mandatoryNegativeTwoValuesInRow(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertEquals(-8193, register.int32Value); + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(-8193, decodeResult.int32Value); - decode(mandatoryInt32Decoder, buffers, register); - assertEquals(-8193, register.int32Value); + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(-8193, decodeResult.int32Value); } @WithByteBuf("00 00 40 81 00 00 40 81") void mandatoryPositiveTwoValuesInRow(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertEquals(8193, register.int32Value); + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int32Value); - decode(mandatoryInt32Decoder, buffers, register); - assertEquals(8193, register.int32Value); + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int32Value); } @WithByteBuf("7f 3f ff 7f 3f ff") void optionalNegativeTwoValuesInRow(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertEquals(-8193, register.int32Value); + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(-8193, decodeResult.int32Value); - decode(nullableInt32Decoder, buffers, register); - assertEquals(-8193, register.int32Value); + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(-8193, decodeResult.int32Value); } @WithByteBuf("00 00 40 82 00 00 40 82") void optionalPositiveTwoValuesInRow(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertEquals(8193, register.int32Value); + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int32Value); - decode(nullableInt32Decoder, buffers, register); - assertEquals(8193, register.int32Value); + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int32Value); } @WithByteBuf("00 39 45 a4") void mandatoryOverlong(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(942756, register.int32Value); + decodeResult.isOverlong = false; + + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(942756, decodeResult.int32Value); } @WithByteBuf("00 40 81") void mandatoryNotOverlong(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(8193, register.int32Value); + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(8193, decodeResult.int32Value); } @WithByteBuf("7f 7c 1b 1b 9d") void mandatoryOverlongNegative(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(-7942755, register.int32Value); + decodeResult.isOverlong = false; + + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(-7942755, decodeResult.int32Value); } @WithByteBuf("7f 3f ff") void mandatoryNotOverlongNegative(Collection buffers) { - decode(mandatoryInt32Decoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(-8193, register.int32Value); + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(-8193, decodeResult.int32Value); } @WithByteBuf("00 39 45 a4") void nullableOverlong(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(942755, register.int32Value); + decodeResult.isOverlong = false; + + decode(nullableInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(942755, decodeResult.int32Value); } @WithByteBuf("00 40 81") void nullableNotOverlong(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(8192, register.int32Value); + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(8192, decodeResult.int32Value); } @WithByteBuf("7f 7c 1b 1b 9d") void nullableOverlongNegative(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(-7942755, register.int32Value); + decodeResult.isOverlong = false; + decode(nullableInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(-7942755, decodeResult.int32Value); } @WithByteBuf("7f 3f ff") void nullableNotOverlongNegative(Collection buffers) { - decode(nullableInt32Decoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(-8193, register.int32Value); + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertEquals(-8193, decodeResult.int32Value); + } + + @BeforeEach + void resetRegisterFlags() { + decodeResult.isOverlong = true; + decodeResult.isNull = true; + decodeResult.isOverflow = true; + decodeResult.int32Value = -999; } } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java index 29859de9..c4f8b310 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java @@ -19,6 +19,7 @@ import com.exactpro.epfast.decoder.message.UnionRegister; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; +import org.junit.jupiter.api.BeforeEach; import java.util.Collection; @@ -31,247 +32,387 @@ class TestInt64 { private DecodeMandatoryInt64 mandatoryInt64Decoder = new DecodeMandatoryInt64(); - private UnionRegister register = new UnionRegister(); + private UnionRegister decodeResult = new UnionRegister(); @WithByteBuf("80") void testNull(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertTrue(register.isNull); + decodeResult.isNull = false; + + decode(nullableInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(decodeResult.int32Value, -999); } @WithByteBuf("81") void optionalZero(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertEquals(0, register.int64Value); + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(0, decodeResult.int64Value); } @WithByteBuf("80") void mandatoryZero(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertEquals(0, register.int64Value); + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(0, decodeResult.int64Value); } @WithByteBuf("01 00 00 00 00 00 00 00 00 80") void testMaxNullable(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertEquals(Long.MAX_VALUE, register.int64Value); + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(Long.MAX_VALUE, decodeResult.int64Value); } @WithByteBuf("00 7f 7f 7f 7f 7f 7f 7f 7f ff") void testMaxMandatory(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertEquals(Long.MAX_VALUE, register.int64Value); + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(Long.MAX_VALUE, decodeResult.int64Value); } @WithByteBuf("7f 00 00 00 00 00 00 00 00 80") void testMinNullable(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertEquals(Long.MIN_VALUE, register.int64Value); + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(Long.MIN_VALUE, decodeResult.int64Value); } @WithByteBuf("7f 00 00 00 00 00 00 00 00 80") void testMinMandatory(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertEquals(Long.MIN_VALUE, register.int64Value); + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(Long.MIN_VALUE, decodeResult.int64Value); } @WithByteBuf("01 00 00 00 00 00 00 00 00 81") void testMaxOverflowNullable1(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("01 00 00 00 00 00 00 00 00 00 80") void testMaxOverflowNullable2(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("01 00 00 00 00 00 00 00 00 80") void testMaxOverflowMandatory1(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("00 7f 00 7f 7f 7f 7f 7f 7f 7f ff") void testMaxOverflowMandatory2(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("77 7f 7f 7f 7f 7f 7f 7f 7f ff") void testMinOverflowNullable1(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("7f 00 00 00 00 00 00 00 00 00 80") void testMinOverflowNullable2(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("77 7f 7f 7f 7f 7f 7f 7f 7f ff") void testMinOverflowMandatory1(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("7f 00 00 00 00 00 00 00 00 00 80") void testMinOverflowMandatory2(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("39 45 a4") void optionalPositive(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertEquals(942755, register.int64Value); + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(942755, decodeResult.int64Value); } @WithByteBuf("39 45 a3") void mandatoryPositive(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertEquals(942755, register.int64Value); + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(942755, decodeResult.int64Value); } @WithByteBuf("46 3a dd") void optionalNegative(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertEquals(-942755, register.int64Value); + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(-942755, decodeResult.int64Value); } @WithByteBuf("7c 1b 1b 9d") void mandatoryNegative(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertEquals(-7942755, register.int64Value); + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(-7942755, decodeResult.int64Value); } @WithByteBuf("ff") void optionalMinusOne(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertEquals(-1, register.int64Value); + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(-1, decodeResult.int64Value); } @WithByteBuf("ff") void mandatoryMinusOne(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertEquals(-1, register.int64Value); + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(-1, decodeResult.int64Value); } @WithByteBuf("00 00 40 82") void optionalSignExtensionPositive(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertEquals(8193, register.int64Value); + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int64Value); } @WithByteBuf("00 00 40 81") void mandatorySignExtensionPositive(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertEquals(8193, register.int64Value); + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int64Value); } @WithByteBuf("7f 3f ff") void optionalSignExtensionNegative(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertEquals(-8193, register.int64Value); + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(-8193, decodeResult.int64Value); } @WithByteBuf("7f 3f ff") void mandatorySignExtensionNegative(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertEquals(-8193, register.int64Value); + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(-8193, decodeResult.int64Value); } @WithByteBuf("7f 3f ff 7f 3f ff") void mandatoryNegativeTwoValuesInRow(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertEquals(-8193, register.int64Value); + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(-8193, decodeResult.int64Value); - decode(mandatoryInt64Decoder, buffers, register); - assertEquals(-8193, register.int64Value); + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(-8193, decodeResult.int64Value); } @WithByteBuf("00 00 40 81 00 00 40 81") void mandatoryPositiveTwoValuesInRow(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertEquals(8193, register.int64Value); + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int64Value); - decode(mandatoryInt64Decoder, buffers, register); - assertEquals(8193, register.int64Value); + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int64Value); } @WithByteBuf("7f 3f ff 7f 3f ff") void optionalNegativeTwoValuesInRow(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertEquals(-8193, register.int64Value); + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(-8193, decodeResult.int64Value); - decode(nullableInt64Decoder, buffers, register); - assertEquals(-8193, register.int64Value); + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(-8193, decodeResult.int64Value); } @WithByteBuf("00 00 40 82 00 00 40 82") void optionalPositiveTwoValuesInRow(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertEquals(8193, register.int64Value); + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int64Value); - decode(nullableInt64Decoder, buffers, register); - assertEquals(8193, register.int64Value); + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int64Value); } @WithByteBuf("00 39 45 a4") void mandatoryOverlong(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(942756, register.int64Value); + decodeResult.isOverlong = false; + + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(942756, decodeResult.int64Value); } @WithByteBuf("00 40 81") void mandatoryNotOverlong(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(8193, register.int64Value); + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(8193, decodeResult.int64Value); } @WithByteBuf("7f 7c 1b 1b 9d") void mandatoryOverlongNegative(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(-7942755, register.int64Value); + decodeResult.isOverlong = false; + + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(-7942755, decodeResult.int64Value); } @WithByteBuf("7f 3f ff") void mandatoryNotOverlongNegative(Collection buffers) { - decode(mandatoryInt64Decoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(-8193, register.int64Value); + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(-8193, decodeResult.int64Value); } @WithByteBuf("00 39 45 a4") void nullableOverlong(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(942755, register.int64Value); + decodeResult.isOverlong = false; + decode(nullableInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(942755, decodeResult.int64Value); } @WithByteBuf("00 40 81") void nullableNotOverlong(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(8192, register.int64Value); + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(8192, decodeResult.int64Value); } @WithByteBuf("7f 7c 1b 1b 9d") void nullableOverlongNegative(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(-7942755, register.int64Value); + decodeResult.isOverlong = false; + + decode(nullableInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(-7942755, decodeResult.int64Value); } @WithByteBuf("7f 3f ff") void nullableNotOverlongNegative(Collection buffers) { - decode(nullableInt64Decoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(-8193, register.int64Value); + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(-8193, decodeResult.int64Value); + } + + @BeforeEach + void resetRegisterFlags() { + decodeResult.isOverlong = true; + decodeResult.isNull = true; + decodeResult.isOverflow = true; + decodeResult.int64Value = -999; } } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java index 02912eb3..e77df942 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java @@ -19,6 +19,7 @@ import com.exactpro.epfast.decoder.message.UnionRegister; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; +import org.junit.jupiter.api.BeforeEach; import java.util.Collection; @@ -31,137 +32,218 @@ class TestUInt32 { private DecodeMandatoryUInt32 mandatoryUInt32Decoder = new DecodeMandatoryUInt32(); - private UnionRegister register = new UnionRegister(); + private UnionRegister decodeResult = new UnionRegister(); @WithByteBuf("80") void testNull(Collection buffers) { - decode(nullableUInt32Decoder, buffers, register); - assertTrue(register.isNull); + decodeResult.isNull = false; + + decode(nullableUInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(-999, decodeResult.uInt32Value); + } @WithByteBuf("81") void optionalZero(Collection buffers) { - decode(nullableUInt32Decoder, buffers, register); - assertEquals(0, register.uInt32Value); + decode(nullableUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(0, decodeResult.uInt32Value); } @WithByteBuf("80") void mandatoryZero(Collection buffers) { - decode(mandatoryUInt32Decoder, buffers, register); - assertEquals(0, register.uInt32Value); + decode(mandatoryUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(0, decodeResult.uInt32Value); } @WithByteBuf("10 00 00 00 80") void testMaxNullable(Collection buffers) { - decode(nullableUInt32Decoder, buffers, register); - assertEquals(4294967295L, register.uInt32Value); + decode(nullableUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(4294967295L, decodeResult.uInt32Value); } @WithByteBuf("0f 7f 7f 7f ff") void testMaxMandatory(Collection buffers) { - decode(mandatoryUInt32Decoder, buffers, register); - assertEquals(4294967295L, register.uInt32Value); + decode(mandatoryUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(4294967295L, decodeResult.uInt32Value); } @WithByteBuf("10 00 00 00 81") void testMaxOverflowNullable1(Collection buffers) { - decode(nullableUInt32Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableUInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("10 00 00 00 00 00 80") void testMaxOverflowNullable2(Collection buffers) { - decode(nullableUInt32Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableUInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("10 00 00 00 80") void testMaxOverflowMandatory1(Collection buffers) { - decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryUInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("0f 7f 7f 7f 7f 00 ff") void testMaxOverflowMandatory2(Collection buffers) { - decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryUInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("39 45 a4") void optionalSimpleNumber(Collection buffers) { - decode(nullableUInt32Decoder, buffers, register); - assertEquals(942755, register.uInt32Value); + decode(nullableUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(942755, decodeResult.uInt32Value); } @WithByteBuf("0f 7f 7f 7f ff") void optionalSimpleNumber2(Collection buffers) { - decode(nullableUInt32Decoder, buffers, register); - assertEquals(4294967294L, register.uInt32Value); + decode(nullableUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(4294967294L, decodeResult.uInt32Value); } @WithByteBuf("39 45 a3") void mandatorySimpleNumber(Collection buffers) { - decode(mandatoryUInt32Decoder, buffers, register); - assertEquals(942755, register.uInt32Value); + decode(mandatoryUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(942755, decodeResult.uInt32Value); } @WithByteBuf("39 45 a4") void optionalSimpleNumberGetValueTwice(Collection buffers) { - decode(nullableUInt32Decoder, buffers, register); - assertEquals(942755, register.uInt32Value); - assertEquals(942755, register.uInt32Value); + decode(nullableUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(942755, decodeResult.uInt32Value); + assertEquals(942755, decodeResult.uInt32Value); } @WithByteBuf("39 45 a3") void mandatorySimpleNumberGetValueTwice(Collection buffers) { - decode(mandatoryUInt32Decoder, buffers, register); - assertEquals(942755, register.uInt32Value); - assertEquals(942755, register.uInt32Value); + decode(mandatoryUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(942755, decodeResult.uInt32Value); + assertEquals(942755, decodeResult.uInt32Value); } @WithByteBuf("39 45 a4 0f 7f 7f 7f ff") void optionalSimpleNumbersTwoValuesInRow(Collection buffers) { - decode(nullableUInt32Decoder, buffers, register); - assertEquals(942755, register.uInt32Value); + decode(nullableUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(942755, decodeResult.uInt32Value); - decode(nullableUInt32Decoder, buffers, register); - assertEquals(4294967294L, register.uInt32Value); + decode(nullableUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(4294967294L, decodeResult.uInt32Value); } @WithByteBuf("39 45 a3 39 45 a3") void mandatorySimpleNumbersTwoValuesInRow(Collection buffers) { - decode(mandatoryUInt32Decoder, buffers, register); - assertEquals(942755, register.uInt32Value); + decode(mandatoryUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(942755, decodeResult.uInt32Value); - decode(mandatoryUInt32Decoder, buffers, register); - assertEquals(942755, register.uInt32Value); + decode(mandatoryUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(942755, decodeResult.uInt32Value); } @WithByteBuf("00 39 45 a4") void mandatoryOverlong(Collection buffers) { - decode(mandatoryUInt32Decoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(942756, register.uInt32Value); + decodeResult.isOverlong = false; + + decode(mandatoryUInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(942756, decodeResult.uInt32Value); } @WithByteBuf("00 40 81") void mandatoryNotOverlong(Collection buffers) { - decode(mandatoryUInt32Decoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(8193, register.uInt32Value); + decode(mandatoryUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(8193, decodeResult.uInt32Value); } @WithByteBuf("00 39 45 a4") void nullableOverlong(Collection buffers) { - decode(nullableUInt32Decoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(942755, register.uInt32Value); + decodeResult.isOverlong = false; + + decode(nullableUInt32Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(942755, decodeResult.uInt32Value); } @WithByteBuf("00 40 81") void nullableNotOverlong(Collection buffers) { - decode(nullableUInt32Decoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(8192, register.uInt32Value); + decode(nullableUInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(8192, decodeResult.uInt32Value); + } + + @BeforeEach + void resetRegisterFlags() { + decodeResult.isOverlong = true; + decodeResult.isNull = true; + decodeResult.isOverflow = true; + decodeResult.uInt32Value = -999; } } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java index e66a21d0..6b115c3d 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java @@ -19,6 +19,7 @@ import com.exactpro.epfast.decoder.message.UnionRegister; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; +import org.junit.jupiter.api.BeforeEach; import java.math.BigInteger; import java.util.Collection; @@ -32,143 +33,226 @@ class TestUInt64 { private DecodeMandatoryUInt64 mandatoryUInt64Decoder = new DecodeMandatoryUInt64(); - private UnionRegister register = new UnionRegister(); + private UnionRegister decodeResult = new UnionRegister(); @WithByteBuf("80") void testNull(Collection buffers) { - decode(nullableUInt64Decoder, buffers, register); - assertTrue(register.isNull); + decodeResult.isNull = false; + decodeResult.uInt64Value = new BigInteger("1"); + + decode(nullableUInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertNull(decodeResult.uInt64Value); } @WithByteBuf("81") void optionalZero(Collection buffers) { - decode(nullableUInt64Decoder, buffers, register); - assertEquals(new BigInteger("0"), register.unsignedInt64Value); + decode(nullableUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(new BigInteger("0"), decodeResult.uInt64Value); } @WithByteBuf("80") void mandatoryZero(Collection buffers) { - decode(mandatoryUInt64Decoder, buffers, register); - assertEquals(new BigInteger("0"), register.unsignedInt64Value); + decode(mandatoryUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(new BigInteger("0"), decodeResult.uInt64Value); } @WithByteBuf("02 00 00 00 00 00 00 00 00 80") void testMaxNullable(Collection buffers) { - decode(nullableUInt64Decoder, buffers, register); - assertEquals(new BigInteger("18446744073709551615"), register.unsignedInt64Value); + decode(nullableUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(new BigInteger("18446744073709551615"), decodeResult.uInt64Value); } @WithByteBuf("01 7f 7f 7f 7f 7f 7f 7f 7f ff") void testMaxMandatory(Collection buffers) { - decode(mandatoryUInt64Decoder, buffers, register); - assertEquals(new BigInteger("18446744073709551615"), register.unsignedInt64Value); + decode(mandatoryUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(new BigInteger("18446744073709551615"), decodeResult.uInt64Value); } @WithByteBuf("02 00 00 00 00 00 00 00 00 81") void testMaxOverflowNullable1(Collection buffers) { - decode(nullableUInt64Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableUInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("02 00 00 00 00 00 00 00 00 00 80") void testMaxOverflowNullable2(Collection buffers) { - decode(nullableUInt64Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + decode(nullableUInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("02 00 00 00 00 00 00 00 00 80") void testMaxOverflowMandatory1(Collection buffers) { - decode(mandatoryUInt64Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryUInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("01 7f 7f 7f 7f 00 7f 7f 7f 7f ff") void testMaxOverflowMandatory2(Collection buffers) { - decode(mandatoryUInt64Decoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryUInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverlong); } @WithByteBuf("39 45 a4") void optionalSimpleNumber1(Collection buffers) { - decode(nullableUInt64Decoder, buffers, register); - assertEquals(new BigInteger("942755"), register.unsignedInt64Value); + decode(nullableUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(new BigInteger("942755"), decodeResult.uInt64Value); } @WithByteBuf("01 7f 7f 7f 7f 7f 7f 7f 7f ff") void optionalSimpleNumber2(Collection buffers) { - decode(nullableUInt64Decoder, buffers, register); - assertEquals(new BigInteger("18446744073709551614"), register.unsignedInt64Value); + decode(nullableUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(new BigInteger("18446744073709551614"), decodeResult.uInt64Value); } @WithByteBuf("39 45 a3") void mandatorySimpleNumber1(Collection buffers) { - decode(mandatoryUInt64Decoder, buffers, register); - assertEquals(new BigInteger("942755"), register.unsignedInt64Value); + decode(mandatoryUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(new BigInteger("942755"), decodeResult.uInt64Value); } @WithByteBuf("01 10 78 20 76 62 2a 62 51 cf") void mandatorySimpleNumber2(Collection buffers) { - decode(mandatoryUInt64Decoder, buffers, register); - assertEquals(new BigInteger("10443992354206034127"), register.unsignedInt64Value); + decode(mandatoryUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(new BigInteger("10443992354206034127"), decodeResult.uInt64Value); } @WithByteBuf("39 45 a4") void optionalSimpleNumber1GetValueTwice(Collection buffers) { - decode(nullableUInt64Decoder, buffers, register); - assertEquals(new BigInteger("942755"), register.unsignedInt64Value); - assertEquals(new BigInteger("942755"), register.unsignedInt64Value); + decode(nullableUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(new BigInteger("942755"), decodeResult.uInt64Value); + assertEquals(new BigInteger("942755"), decodeResult.uInt64Value); } @WithByteBuf("39 45 a3") void mandatorySimpleNumber1GetValueTwice(Collection buffers) { - decode(mandatoryUInt64Decoder, buffers, register); - assertEquals(new BigInteger("942755"), register.unsignedInt64Value); - assertEquals(new BigInteger("942755"), register.unsignedInt64Value); + decode(mandatoryUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(new BigInteger("942755"), decodeResult.uInt64Value); + assertEquals(new BigInteger("942755"), decodeResult.uInt64Value); } @WithByteBuf("39 45 a4 01 7f 7f 7f 7f 7f 7f 7f 7f ff") void optionalSimpleNumbersTwoValuesInRow(Collection buffers) { - decode(nullableUInt64Decoder, buffers, register); - assertEquals(new BigInteger("942755"), register.unsignedInt64Value); + decode(nullableUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(new BigInteger("942755"), decodeResult.uInt64Value); - decode(nullableUInt64Decoder, buffers, register); - assertEquals(new BigInteger("18446744073709551614"), register.unsignedInt64Value); + decode(nullableUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(new BigInteger("18446744073709551614"), decodeResult.uInt64Value); } @WithByteBuf("39 45 a3 01 10 78 20 76 62 2a 62 51 cf") void mandatorySimpleNumbersTwoValuesInRow(Collection buffers) { - decode(mandatoryUInt64Decoder, buffers, register); - assertEquals(new BigInteger("942755"), register.unsignedInt64Value); + decode(mandatoryUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(new BigInteger("942755"), decodeResult.uInt64Value); - decode(mandatoryUInt64Decoder, buffers, register); - assertEquals(new BigInteger("10443992354206034127"), register.unsignedInt64Value); + decode(mandatoryUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isOverlong); + assertEquals(new BigInteger("10443992354206034127"), decodeResult.uInt64Value); } @WithByteBuf("00 39 45 a4") void mandatoryOverlong(Collection buffers) { - decode(mandatoryUInt64Decoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(new BigInteger("942756"), register.unsignedInt64Value); + decodeResult.isOverlong = false; + + decode(mandatoryUInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(new BigInteger("942756"), decodeResult.uInt64Value); } @WithByteBuf("00 40 81") void mandatoryNotOverlong(Collection buffers) { - decode(mandatoryUInt64Decoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigInteger("8193"), register.unsignedInt64Value); + decode(mandatoryUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(new BigInteger("8193"), decodeResult.uInt64Value); } @WithByteBuf("00 39 45 a4") void nullableOverlong(Collection buffers) { - decode(nullableUInt64Decoder, buffers, register); - assertTrue(register.isOverlong); - assertEquals(new BigInteger("942755"), register.unsignedInt64Value); + decodeResult.isOverlong = false; + + decode(nullableUInt64Decoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(new BigInteger("942755"), decodeResult.uInt64Value); } @WithByteBuf("00 40 81") void nullableNotOverlong(Collection buffers) { - decode(nullableUInt64Decoder, buffers, register); - assertFalse(register.isOverlong); - assertEquals(new BigInteger("8192"), register.unsignedInt64Value); + decode(nullableUInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals(new BigInteger("8192"), decodeResult.uInt64Value); + } + + @BeforeEach + void resetRegisterFlags() { + decodeResult.isOverlong = true; + decodeResult.isNull = true; + decodeResult.isOverflow = true; + decodeResult.uInt64Value = null; } } diff --git a/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java b/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java index d8877d41..226042b4 100644 --- a/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java +++ b/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java @@ -19,6 +19,7 @@ import com.exactpro.epfast.decoder.message.UnionRegister; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; +import org.junit.jupiter.api.BeforeEach; import java.util.Collection; @@ -29,46 +30,54 @@ class TestDecodePresenceMap { private DecodePresenceMap presenceMapDecoder = new DecodePresenceMap(); - private UnionRegister register = new UnionRegister(); + private UnionRegister decodeResult = new UnionRegister(); @WithByteBuf("95") //0b10010101 void testSingleByte(Collection buffers) { - decode(presenceMapDecoder, buffers, register); - PresenceMap presenceMap = register.presenceMap; - assertTrue(presenceMap.getValue(0)); - assertFalse(presenceMap.getValue(1)); - assertTrue(presenceMap.getValue(2)); - assertFalse(presenceMap.getValue(3)); - assertTrue(presenceMap.getValue(4)); - assertFalse(presenceMap.getValue(5)); - assertFalse(presenceMap.getValue(6)); + decode(presenceMapDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertTrue(decodeResult.presenceMap.getValue(0)); + assertFalse(decodeResult.presenceMap.getValue(1)); + assertTrue(decodeResult.presenceMap.getValue(2)); + assertFalse(decodeResult.presenceMap.getValue(3)); + assertTrue(decodeResult.presenceMap.getValue(4)); + assertFalse(decodeResult.presenceMap.getValue(5)); + assertFalse(decodeResult.presenceMap.getValue(6)); } @WithByteBuf("15 15 00 00 00 80") void testOverlong(Collection buffers) { - decode(presenceMapDecoder, buffers, register); - PresenceMap presenceMap = register.presenceMap; - assertTrue(presenceMap.getValue(0)); - assertFalse(presenceMap.getValue(1)); - assertTrue(presenceMap.getValue(2)); - assertFalse(presenceMap.getValue(3)); - assertTrue(presenceMap.getValue(4)); - assertFalse(presenceMap.getValue(5)); - assertFalse(presenceMap.getValue(6)); - assertTrue(register.isOverlong); + decode(presenceMapDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertTrue(decodeResult.presenceMap.getValue(0)); + assertFalse(decodeResult.presenceMap.getValue(1)); + assertTrue(decodeResult.presenceMap.getValue(2)); + assertFalse(decodeResult.presenceMap.getValue(3)); + assertTrue(decodeResult.presenceMap.getValue(4)); + assertFalse(decodeResult.presenceMap.getValue(5)); + assertFalse(decodeResult.presenceMap.getValue(6)); } @WithByteBuf("15 15 00 00 00 82") void testTruncateWhenNotOverlong(Collection buffers) { - decode(presenceMapDecoder, buffers, register); - PresenceMap presenceMap = register.presenceMap; - assertTrue(presenceMap.getValue(0)); - assertFalse(presenceMap.getValue(1)); - assertTrue(presenceMap.getValue(2)); - assertFalse(presenceMap.getValue(3)); - assertTrue(presenceMap.getValue(4)); - assertFalse(presenceMap.getValue(5)); - assertFalse(presenceMap.getValue(6)); - assertFalse(register.isOverlong); + decode(presenceMapDecoder, buffers, decodeResult); + assertFalse(decodeResult.isOverlong); + assertFalse(decodeResult.isNull); + assertTrue(decodeResult.presenceMap.getValue(0)); + assertFalse(decodeResult.presenceMap.getValue(1)); + assertTrue(decodeResult.presenceMap.getValue(2)); + assertFalse(decodeResult.presenceMap.getValue(3)); + assertTrue(decodeResult.presenceMap.getValue(4)); + assertFalse(decodeResult.presenceMap.getValue(5)); + assertFalse(decodeResult.presenceMap.getValue(6)); + } + + @BeforeEach + void resetRegisterFlags() { + decodeResult.isOverlong = true; + decodeResult.isNull = true; + decodeResult.presenceMap = null; } } diff --git a/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java b/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java index b09108f2..fdc257fb 100644 --- a/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java +++ b/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java @@ -19,6 +19,7 @@ import com.exactpro.epfast.decoder.message.UnionRegister; import com.exactpro.junit5.WithByteBuf; import io.netty.buffer.ByteBuf; +import org.junit.jupiter.api.BeforeEach; import java.nio.charset.StandardCharsets; import java.util.Collection; @@ -32,91 +33,134 @@ class TestDecodeByteVector { private DecodeMandatoryByteVector mandatoryByteVectorDecoder = new DecodeMandatoryByteVector(); - private UnionRegister register = new UnionRegister(); + private UnionRegister decodeResult = new UnionRegister(); @WithByteBuf("80") void testNull(Collection buffers) { - decode(nullableByteVectorDecoder, buffers, register); - assertNull(register.byteVectorValue); + decodeResult.isNull = false; + + decode(nullableByteVectorDecoder, buffers, decodeResult); + assertTrue(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertNull(decodeResult.byteVectorValue); } @WithByteBuf("81") void testNullableZeroLen(Collection buffers) { - decode(nullableByteVectorDecoder, buffers, register); - assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); + decode(nullableByteVectorDecoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals("", new String(decodeResult.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("80") void testMandatoryZeroLen(Collection buffers) { - decode(mandatoryByteVectorDecoder, buffers, register); - assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); + decode(mandatoryByteVectorDecoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals("", new String(decodeResult.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("10 00 00 00 81 41 42 42 43 44 45") void testNullableLengthOverflow1(Collection buffers) { - decode(nullableByteVectorDecoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableByteVectorDecoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertTrue(decodeResult.isOverflow); } @WithByteBuf("10 00 00 00 00 00 80 41 42 42 43 44 45") void testNullableLengthOverflow2(Collection buffers) { - decode(nullableByteVectorDecoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(nullableByteVectorDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); } @WithByteBuf("10 00 00 00 80 41 42 42 43 44 45") void testMandatoryLengthOverflow1(Collection buffers) { - decode(mandatoryByteVectorDecoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryByteVectorDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); } @WithByteBuf("0f 7f 7f 7f 7f 00 ff 41 42 42 43 44 45") void testMandatoryLengthOverflow2(Collection buffers) { - decode(mandatoryByteVectorDecoder, buffers, register); - assertTrue(register.isOverflow); + decodeResult.isOverflow = false; + + decode(mandatoryByteVectorDecoder, buffers, decodeResult); + assertTrue(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); } @WithByteBuf("87 41 42 42 43 44 45") void testSimpleNullableVector(Collection buffers) { - decode(nullableByteVectorDecoder, buffers, register); - assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); + decode(nullableByteVectorDecoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals("ABBCDE", new String(decodeResult.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("86 41 42 42 43 44 45") void testSimpleMandatoryVector(Collection buffers) { - decode(mandatoryByteVectorDecoder, buffers, register); - assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); + decode(mandatoryByteVectorDecoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals("ABBCDE", new String(decodeResult.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("81") void testNullableZeroLenGetValueTwice(Collection buffers) { - decode(nullableByteVectorDecoder, buffers, register); - assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); - assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); + decode(nullableByteVectorDecoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals("", new String(decodeResult.byteVectorValue, StandardCharsets.UTF_8)); + assertEquals("", new String(decodeResult.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("80") void testMandatoryZeroLenGetValueTwice(Collection buffers) { - decode(mandatoryByteVectorDecoder, buffers, register); - assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); - assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); + decode(mandatoryByteVectorDecoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals("", new String(decodeResult.byteVectorValue, StandardCharsets.UTF_8)); + assertEquals("", new String(decodeResult.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("87 41 42 42 43 44 45 81") void testSimpleNullableVectorTwoValuesInRow(Collection buffers) { - decode(nullableByteVectorDecoder, buffers, register); - assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); - - decode(nullableByteVectorDecoder, buffers, register); - assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); + decode(nullableByteVectorDecoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals("ABBCDE", new String(decodeResult.byteVectorValue, StandardCharsets.UTF_8)); + + decode(nullableByteVectorDecoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals("", new String(decodeResult.byteVectorValue, StandardCharsets.UTF_8)); } @WithByteBuf("86 41 42 42 43 44 45 80") void testSimpleMandatoryVectorTwoValuesInRow(Collection buffers) { - decode(mandatoryByteVectorDecoder, buffers, register); - assertEquals("ABBCDE", new String(register.byteVectorValue, StandardCharsets.UTF_8)); + decode(mandatoryByteVectorDecoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals("ABBCDE", new String(decodeResult.byteVectorValue, StandardCharsets.UTF_8)); + + decode(mandatoryByteVectorDecoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertEquals("", new String(decodeResult.byteVectorValue, StandardCharsets.UTF_8)); + } - decode(mandatoryByteVectorDecoder, buffers, register); - assertEquals("", new String(register.byteVectorValue, StandardCharsets.UTF_8)); + @BeforeEach + void resetRegisterFlags() { + decodeResult.isNull = true; + decodeResult.isOverflow = true; + decodeResult.presenceMap = null; } } From b37fabe884b4bdbaff5a656fdd20840c0ae0a213 Mon Sep 17 00:00:00 2001 From: vdonadze Date: Sun, 9 Aug 2020 13:48:04 +0400 Subject: [PATCH 11/20] removed extra zero from positive sign extensions. set null flag to false when overflow --- .../decoder/integer/DecodeMandatoryInt32.java | 2 +- .../decoder/integer/DecodeMandatoryInt64.java | 2 +- .../integer/DecodeMandatoryUInt32.java | 3 +- .../integer/DecodeMandatoryUInt64.java | 3 +- .../decoder/integer/DecodeNullableInt32.java | 1 + .../decoder/integer/DecodeNullableInt64.java | 1 + .../epfast/decoder/integer/TestInt32.java | 30 ++++++++++++++--- .../epfast/decoder/integer/TestInt64.java | 32 ++++++++++++++++--- 8 files changed, 59 insertions(+), 15 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java index 6d19de83..2e3bad0a 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java @@ -99,12 +99,12 @@ public int decode(ByteBuf buf, UnionRegister register) { public void setResult(UnionRegister register) { inProgress = false; register.isOverlong = overlong; + register.isNull = false; if (overflow) { register.isOverflow = true; register.infoMessage = "Int32 Overflow"; } else { register.isOverflow = false; - register.isNull = false; register.int32Value = value; } reset(); diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java index 7714d7f9..defeb111 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java @@ -99,12 +99,12 @@ public int decode(ByteBuf buf, UnionRegister register) { public void setResult(UnionRegister register) { inProgress = false; register.isOverlong = overlong; + register.isNull = false; if (overflow) { register.isOverflow = true; register.infoMessage = "Int64 Overflow"; } else { register.isOverflow = false; - register.isNull = false; register.int64Value = value; } reset(); diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java index a197e083..5f4b9fda 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java @@ -69,13 +69,12 @@ public int decode(ByteBuf buf, UnionRegister register) { public void setResult(UnionRegister register) { inProgress = false; register.isOverlong = overlong; + register.isNull = false; if (overflow) { register.isOverflow = true; - register.isNull = false; register.infoMessage = "UInt32 Overflow"; } else { register.isOverflow = false; - register.isNull = false; register.uInt32Value = value & 0x0_FFFFFFFFL; } reset(); diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java index 1a9d8a83..e4e0178b 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java @@ -73,14 +73,13 @@ public int decode(ByteBuf buf, UnionRegister register) { public void setResult(UnionRegister register) { inProgress = false; register.isOverlong = overlong; + register.isNull = false; if (overflow) { register.isOverflow = true; - register.isNull = false; register.infoMessage = "UInt32 Overflow"; } else { longToBytes(value, bytes); register.isOverflow = false; - register.isNull = false; register.uInt64Value = new BigInteger(1, bytes); } reset(); diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java index aa1d110d..2ea84493 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java @@ -105,6 +105,7 @@ public void setResult(UnionRegister register) { register.isOverlong = overlong; if (overflow) { register.isOverflow = true; + register.isNull = false; register.infoMessage = "Int32 Overflow"; } else { register.isOverflow = false; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java index 4779ab2a..740c5078 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java @@ -105,6 +105,7 @@ public void setResult(UnionRegister register) { register.isOverlong = overlong; if (overflow) { register.isOverflow = true; + register.isNull = false; register.infoMessage = "Int64 Overflow"; } else { register.isOverflow = false; diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java index 791e79f7..c1e0e037 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java @@ -230,7 +230,7 @@ void mandatoryMinusOne(Collection buffers) { assertEquals(-1, decodeResult.int32Value); } - @WithByteBuf("00 00 40 82") + @WithByteBuf("00 40 82") void optionalSignExtensionPositive(Collection buffers) { decode(nullableInt32Decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); @@ -239,7 +239,18 @@ void optionalSignExtensionPositive(Collection buffers) { assertEquals(8193, decodeResult.int32Value); } - @WithByteBuf("00 00 40 81") + @WithByteBuf("00 00 40 82") + void optionalSignExtensionPositiveOverlong(Collection buffers) { + decodeResult.isOverlong = false; + + decode(nullableInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertTrue(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int32Value); + } + + @WithByteBuf("00 40 81") void mandatorySignExtensionPositive(Collection buffers) { decode(mandatoryInt32Decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); @@ -248,6 +259,17 @@ void mandatorySignExtensionPositive(Collection buffers) { assertEquals(8193, decodeResult.int32Value); } + @WithByteBuf("00 00 40 81") + void mandatorySignExtensionPositiveOverlong(Collection buffers) { + decodeResult.isOverlong = false; + + decode(mandatoryInt32Decoder, buffers, decodeResult); + assertFalse(decodeResult.isOverflow); + assertFalse(decodeResult.isNull); + assertTrue(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int32Value); + } + @WithByteBuf("7f 3f ff") void optionalSignExtensionNegative(Collection buffers) { decode(nullableInt32Decoder, buffers, decodeResult); @@ -281,7 +303,7 @@ void mandatoryNegativeTwoValuesInRow(Collection buffers) { assertEquals(-8193, decodeResult.int32Value); } - @WithByteBuf("00 00 40 81 00 00 40 81") + @WithByteBuf("00 40 81 00 40 81") void mandatoryPositiveTwoValuesInRow(Collection buffers) { decode(mandatoryInt32Decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); @@ -311,7 +333,7 @@ void optionalNegativeTwoValuesInRow(Collection buffers) { assertEquals(-8193, decodeResult.int32Value); } - @WithByteBuf("00 00 40 82 00 00 40 82") + @WithByteBuf("00 40 82 00 40 82") void optionalPositiveTwoValuesInRow(Collection buffers) { decode(nullableInt32Decoder, buffers, decodeResult); assertFalse(decodeResult.isOverflow); diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java index c4f8b310..70286238 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java @@ -42,7 +42,7 @@ void testNull(Collection buffers) { assertTrue(decodeResult.isNull); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isOverlong); - assertEquals(decodeResult.int32Value, -999); + assertEquals(decodeResult.int64Value, -999); } @WithByteBuf("81") @@ -233,7 +233,7 @@ void mandatoryMinusOne(Collection buffers) { assertEquals(-1, decodeResult.int64Value); } - @WithByteBuf("00 00 40 82") + @WithByteBuf("00 40 82") void optionalSignExtensionPositive(Collection buffers) { decode(nullableInt64Decoder, buffers, decodeResult); assertFalse(decodeResult.isNull); @@ -242,7 +242,18 @@ void optionalSignExtensionPositive(Collection buffers) { assertEquals(8193, decodeResult.int64Value); } - @WithByteBuf("00 00 40 81") + @WithByteBuf("00 00 40 82") + void optionalSignExtensionPositiveOverlong(Collection buffers) { + decodeResult.isOverlong = false; + + decode(nullableInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertTrue(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int64Value); + } + + @WithByteBuf("00 40 81") void mandatorySignExtensionPositive(Collection buffers) { decode(mandatoryInt64Decoder, buffers, decodeResult); assertFalse(decodeResult.isNull); @@ -251,6 +262,17 @@ void mandatorySignExtensionPositive(Collection buffers) { assertEquals(8193, decodeResult.int64Value); } + @WithByteBuf("00 00 40 81") + void mandatorySignExtensionPositiveOverlong(Collection buffers) { + decodeResult.isOverlong = false; + + decode(mandatoryInt64Decoder, buffers, decodeResult); + assertFalse(decodeResult.isNull); + assertFalse(decodeResult.isOverflow); + assertTrue(decodeResult.isOverlong); + assertEquals(8193, decodeResult.int64Value); + } + @WithByteBuf("7f 3f ff") void optionalSignExtensionNegative(Collection buffers) { decode(nullableInt64Decoder, buffers, decodeResult); @@ -284,7 +306,7 @@ void mandatoryNegativeTwoValuesInRow(Collection buffers) { assertEquals(-8193, decodeResult.int64Value); } - @WithByteBuf("00 00 40 81 00 00 40 81") + @WithByteBuf("00 40 81 00 40 81") void mandatoryPositiveTwoValuesInRow(Collection buffers) { decode(mandatoryInt64Decoder, buffers, decodeResult); assertFalse(decodeResult.isNull); @@ -314,7 +336,7 @@ void optionalNegativeTwoValuesInRow(Collection buffers) { assertEquals(-8193, decodeResult.int64Value); } - @WithByteBuf("00 00 40 82 00 00 40 82") + @WithByteBuf("00 40 82 00 40 82") void optionalPositiveTwoValuesInRow(Collection buffers) { decode(nullableInt64Decoder, buffers, decodeResult); assertFalse(decodeResult.isNull); From da0545225a2a932a9f23b51f1ab9e54242c1e9dc Mon Sep 17 00:00:00 2001 From: vdonadze Date: Wed, 19 Aug 2020 15:32:22 +0400 Subject: [PATCH 12/20] working version --- .../epfast/decoder/IDecodeContext.java | 21 ++++++++++++++----- .../decoder/ascii/DecodeAsciiString.java | 2 +- .../epfast/decoder/decimal/DecodeDecimal.java | 2 +- .../epfast/decoder/integer/DecodeInteger.java | 2 +- .../epfast/decoder/message/FastCompiler.java | 14 +++++++------ .../presencemap/DecodePresenceMap.java | 2 +- .../decoder/unicode/DecodeByteVector.java | 2 +- 7 files changed, 29 insertions(+), 16 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java index 9e2d9886..7a0b65d1 100644 --- a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java +++ b/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java @@ -16,16 +16,27 @@ package com.exactpro.epfast.decoder; +import com.exactpro.epfast.decoder.message.DecoderCommand; +import com.exactpro.epfast.decoder.message.DecoderState; import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; -public interface IDecodeContext { +public abstract class IDecodeContext implements DecoderCommand { - int FINISHED = 1; + protected static final int FINISHED = 1; - int MORE_DATA_NEEDED = 0; + public static final int MORE_DATA_NEEDED = 0; - int CLEAR_STOP_BIT_MASK = 0b01111111; + protected static final int CLEAR_STOP_BIT_MASK = 0b01111111; - int decode(ByteBuf buf, UnionRegister register); + public abstract int decode(ByteBuf buf, UnionRegister register); + + @Override + public int executeOn(DecoderState decoderState) { + if (!decoderState.inputBuffer.isReadable()) { + decoderState.canProceed = false; + return 0; + } + return decode(decoderState.inputBuffer, decoderState.register); + } } diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java index 9c8b1bb4..5bb38004 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java @@ -20,7 +20,7 @@ import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; -public abstract class DecodeAsciiString implements IDecodeContext { +public abstract class DecodeAsciiString extends IDecodeContext { final StringBuilder stringBuilder = new StringBuilder(); diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java index 2adecbc7..c34ca5e4 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java @@ -20,7 +20,7 @@ import com.exactpro.epfast.decoder.integer.DecodeMandatoryInt64; import com.exactpro.epfast.decoder.message.UnionRegister; -public abstract class DecodeDecimal implements IDecodeContext { +public abstract class DecodeDecimal extends IDecodeContext { DecodeMandatoryInt64 mantissaDecoder = new DecodeMandatoryInt64(); diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java index 5bcf934e..840bc3c9 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java @@ -19,7 +19,7 @@ import com.exactpro.epfast.decoder.IDecodeContext; import com.exactpro.epfast.decoder.message.UnionRegister; -public abstract class DecodeInteger implements IDecodeContext { +public abstract class DecodeInteger extends IDecodeContext { static final int SIGN_BIT_MASK = 0b01000000; diff --git a/src/main/java/com/exactpro/epfast/decoder/message/FastCompiler.java b/src/main/java/com/exactpro/epfast/decoder/message/FastCompiler.java index 6dad87e4..4d4720cb 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/FastCompiler.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/FastCompiler.java @@ -16,10 +16,12 @@ package com.exactpro.epfast.decoder.message; +import com.exactpro.epfast.decoder.ascii.DecodeMandatoryAsciiString; +import com.exactpro.epfast.decoder.ascii.DecodeNullableAsciiString; +import com.exactpro.epfast.decoder.integer.DecodeMandatoryInt32; +import com.exactpro.epfast.decoder.integer.DecodeNullableInt32; import com.exactpro.epfast.decoder.message.commands.*; import com.exactpro.epfast.decoder.message.commands.InitIndexedProperty; -import com.exactpro.epfast.decoder.message.commands.ascii.ReadMandatoryAsciiString; -import com.exactpro.epfast.decoder.message.commands.ascii.ReadNullableAsciiString; import com.exactpro.epfast.decoder.message.commands.ascii.SetString; import com.exactpro.epfast.decoder.message.commands.integer.*; import com.exactpro.epfast.decoder.message.commands.operators.AllOtherOperatorsMissingValue; @@ -118,11 +120,11 @@ private void compileFieldInstruction(FieldInstruction instruction) { presenceBitIndex++; } if (instruction.isOptional()) { - commandSet.add(new ReadNullableInt32()); + commandSet.add(new DecodeNullableInt32()); addOperator(operator); commandSet.add(new SetNullableInt32(instruction.getFieldId())); } else { - commandSet.add(new ReadMandatoryInt32()); + commandSet.add(new DecodeMandatoryInt32()); addOperator(operator); commandSet.add(new SetMandatoryInt32(instruction.getFieldId())); } @@ -134,9 +136,9 @@ private void compileFieldInstruction(FieldInstruction instruction) { presenceBitIndex++; } if (instruction.isOptional()) { - commandSet.add(new ReadNullableAsciiString()); + commandSet.add(new DecodeNullableAsciiString()); } else { - commandSet.add(new ReadMandatoryAsciiString()); + commandSet.add(new DecodeMandatoryAsciiString()); } addOperator(operator); commandSet.add(new SetString(instruction.getFieldId())); diff --git a/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java b/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java index 720c8836..a4e62e65 100644 --- a/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java +++ b/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java @@ -22,7 +22,7 @@ import java.util.BitSet; -public class DecodePresenceMap implements IDecodeContext { +public class DecodePresenceMap extends IDecodeContext { private BitSet value = new BitSet(); diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java index 8d95ebf1..e15ed37e 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java @@ -22,7 +22,7 @@ import java.util.ArrayList; import java.util.List; -public abstract class DecodeByteVector implements IDecodeContext { +public abstract class DecodeByteVector extends IDecodeContext { List value = new ArrayList<>(); From 6289f96f52a836efbb157b06c3ee6176143c1f44 Mon Sep 17 00:00:00 2001 From: vdonadze Date: Wed, 19 Aug 2020 19:15:05 +0400 Subject: [PATCH 13/20] removed extra classes --- .../epfast/decoder/message/FastCompiler.java | 10 +++-- .../message/InstructionWithDecoder.java | 42 ------------------- .../decoder/message/PrimitiveInstruction.java | 30 ------------- .../ascii/ReadMandatoryAsciiString.java | 27 ------------ .../ascii/ReadNullableAsciiString.java | 28 ------------- .../decimal/ReadMandatoryCompoundDecimal.java | 27 ------------ .../decimal/ReadMandatorySimpleDecimal.java | 26 ------------ .../decimal/ReadNullableCompoundDecimal.java | 27 ------------ .../decimal/ReadNullableSimpleDecimal.java | 27 ------------ .../commands/integer/ReadMandatoryInt32.java | 27 ------------ .../commands/integer/ReadMandatoryInt64.java | 27 ------------ .../commands/integer/ReadMandatoryUInt32.java | 28 ------------- .../commands/integer/ReadMandatoryUInt64.java | 28 ------------- .../commands/integer/ReadNullableInt32.java | 27 ------------ .../commands/integer/ReadNullableInt64.java | 27 ------------ .../commands/integer/ReadNullableUInt32.java | 26 ------------ .../commands/integer/ReadNullableUInt64.java | 26 ------------ .../commands/presencemap/ReadPresenceMap.java | 28 ------------- .../unicode/ReadMandatoryByteVector.java | 27 ------------ 19 files changed, 6 insertions(+), 509 deletions(-) delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadMandatoryAsciiString.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadNullableAsciiString.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatoryCompoundDecimal.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatorySimpleDecimal.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadNullableCompoundDecimal.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadNullableSimpleDecimal.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryInt32.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryInt64.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt32.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt64.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt32.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt64.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt32.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt64.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/presencemap/ReadPresenceMap.java delete mode 100644 src/main/java/com/exactpro/epfast/decoder/message/commands/unicode/ReadMandatoryByteVector.java diff --git a/src/main/java/com/exactpro/epfast/decoder/message/FastCompiler.java b/src/main/java/com/exactpro/epfast/decoder/message/FastCompiler.java index 4d4720cb..e8f05875 100644 --- a/src/main/java/com/exactpro/epfast/decoder/message/FastCompiler.java +++ b/src/main/java/com/exactpro/epfast/decoder/message/FastCompiler.java @@ -19,7 +19,9 @@ import com.exactpro.epfast.decoder.ascii.DecodeMandatoryAsciiString; import com.exactpro.epfast.decoder.ascii.DecodeNullableAsciiString; import com.exactpro.epfast.decoder.integer.DecodeMandatoryInt32; +import com.exactpro.epfast.decoder.integer.DecodeMandatoryUInt32; import com.exactpro.epfast.decoder.integer.DecodeNullableInt32; +import com.exactpro.epfast.decoder.integer.DecodeNullableUInt32; import com.exactpro.epfast.decoder.message.commands.*; import com.exactpro.epfast.decoder.message.commands.InitIndexedProperty; import com.exactpro.epfast.decoder.message.commands.ascii.SetString; @@ -29,8 +31,8 @@ import com.exactpro.epfast.decoder.message.commands.operators.DefaultMissingValue; import com.exactpro.epfast.decoder.message.commands.operators.DefaultPresentValue; import com.exactpro.epfast.decoder.message.commands.presencemap.CheckPresenceBit; -import com.exactpro.epfast.decoder.message.commands.presencemap.ReadPresenceMap; import com.exactpro.epfast.decoder.message.commands.presencemap.SetPresenceMap; +import com.exactpro.epfast.decoder.presencemap.DecodePresenceMap; import com.exactpro.epfast.template.*; import java.util.*; @@ -66,7 +68,7 @@ private void compile( commandSet.add(new InitApplicationType(typeRef)); } if (requiresPresenceMap(instructions)) { - commandSet.add(new ReadPresenceMap()); + commandSet.add(new DecodePresenceMap()); commandSet.add(new SetPresenceMap()); } for (Instruction instruction : instructions) { @@ -96,10 +98,10 @@ private void compileGroup(Group group) { private void compileSequence(Sequence sequence) { if (sequence.isOptional()) { - commandSet.add(new ReadNullableUInt32()); + commandSet.add(new DecodeNullableUInt32()); commandSet.add(new SetNullableLengthField()); } else { - commandSet.add(new ReadMandatoryUInt32()); + commandSet.add(new DecodeMandatoryUInt32()); commandSet.add(new SetMandatoryLengthField()); } commandSet.add(new InitIndexedProperty(sequence.getFieldId())); diff --git a/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java b/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java deleted file mode 100644 index 5a6e7011..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/InstructionWithDecoder.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright 2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message; - -import com.exactpro.epfast.decoder.IDecodeContext; -import com.exactpro.epfast.decoder.OverflowException; - -import java.util.Objects; - -public abstract class InstructionWithDecoder implements DecoderCommand { - - protected T fieldDecoder; - - protected InstructionWithDecoder(T fieldDecoder) { - this.fieldDecoder = Objects.requireNonNull(fieldDecoder); - } - - protected abstract int decode(DecoderState decoderState) throws OverflowException; - - @Override - public int executeOn(DecoderState decoderState) throws OverflowException { - if (!decoderState.inputBuffer.isReadable()) { - decoderState.canProceed = false; - return 0; - } - return decode(decoderState); - } -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java b/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java deleted file mode 100644 index 6128b4c3..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/PrimitiveInstruction.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright 2019-2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message; - -import com.exactpro.epfast.decoder.IDecodeContext; - -public abstract class PrimitiveInstruction extends InstructionWithDecoder { - - protected PrimitiveInstruction(T fieldDecoder) { - super(fieldDecoder); - } - - protected int decode(DecoderState decoderState) { - return fieldDecoder.decode(decoderState.inputBuffer, decoderState.register); - } -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadMandatoryAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadMandatoryAsciiString.java deleted file mode 100644 index e0c78631..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadMandatoryAsciiString.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright 2019-2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.ascii; - -import com.exactpro.epfast.decoder.ascii.DecodeMandatoryAsciiString; -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; - -public class ReadMandatoryAsciiString extends PrimitiveInstruction { - - public ReadMandatoryAsciiString() { - super(new DecodeMandatoryAsciiString()); - } -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadNullableAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadNullableAsciiString.java deleted file mode 100644 index 895ea5c7..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/ascii/ReadNullableAsciiString.java +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Copyright 2019-2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.ascii; - -import com.exactpro.epfast.decoder.ascii.DecodeNullableAsciiString; -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; - -public class ReadNullableAsciiString extends PrimitiveInstruction { - - public ReadNullableAsciiString() { - super(new DecodeNullableAsciiString()); - } - -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatoryCompoundDecimal.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatoryCompoundDecimal.java deleted file mode 100644 index e4e7ae93..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatoryCompoundDecimal.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright 2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.decimal; - -import com.exactpro.epfast.decoder.decimal.DecodeMandatoryDecimal; -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; - -public class ReadMandatoryCompoundDecimal extends PrimitiveInstruction { - - public ReadMandatoryCompoundDecimal() { - super(new DecodeMandatoryDecimal()); - } -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatorySimpleDecimal.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatorySimpleDecimal.java deleted file mode 100644 index b9bbb370..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadMandatorySimpleDecimal.java +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright 2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.decimal; - -import com.exactpro.epfast.decoder.decimal.DecodeMandatoryDecimal; -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; - -public class ReadMandatorySimpleDecimal extends PrimitiveInstruction { - public ReadMandatorySimpleDecimal() { - super(new DecodeMandatoryDecimal()); - } -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadNullableCompoundDecimal.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadNullableCompoundDecimal.java deleted file mode 100644 index 79b77c5f..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadNullableCompoundDecimal.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright 2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.decimal; - -import com.exactpro.epfast.decoder.decimal.DecodeNullableDecimal; -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; - -public class ReadNullableCompoundDecimal extends PrimitiveInstruction { - - public ReadNullableCompoundDecimal() { - super(new DecodeNullableDecimal()); - } -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadNullableSimpleDecimal.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadNullableSimpleDecimal.java deleted file mode 100644 index 792f7b91..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/decimal/ReadNullableSimpleDecimal.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright 2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.decimal; - -import com.exactpro.epfast.decoder.decimal.DecodeNullableDecimal; -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; - -public class ReadNullableSimpleDecimal extends PrimitiveInstruction { - - public ReadNullableSimpleDecimal() { - super(new DecodeNullableDecimal()); - } -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryInt32.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryInt32.java deleted file mode 100644 index d4463976..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryInt32.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright 2019-2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.integer; - -import com.exactpro.epfast.decoder.integer.DecodeMandatoryInt32; -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; - -public class ReadMandatoryInt32 extends PrimitiveInstruction { - - public ReadMandatoryInt32() { - super(new DecodeMandatoryInt32()); - } -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryInt64.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryInt64.java deleted file mode 100644 index d7c95503..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryInt64.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright 2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.integer; - -import com.exactpro.epfast.decoder.integer.DecodeMandatoryInt64; -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; - -public class ReadMandatoryInt64 extends PrimitiveInstruction { - public ReadMandatoryInt64() { - super(new DecodeMandatoryInt64()); - } - -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt32.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt32.java deleted file mode 100644 index 85788cf5..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt32.java +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Copyright 2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.integer; - -import com.exactpro.epfast.decoder.integer.DecodeMandatoryUInt32; -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; - -public class ReadMandatoryUInt32 extends PrimitiveInstruction { - - public ReadMandatoryUInt32() { - super(new DecodeMandatoryUInt32()); - } - -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt64.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt64.java deleted file mode 100644 index 967f332e..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadMandatoryUInt64.java +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Copyright 2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.integer; - -import com.exactpro.epfast.decoder.integer.DecodeMandatoryUInt64; -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; - -public class ReadMandatoryUInt64 extends PrimitiveInstruction { - - public ReadMandatoryUInt64() { - super(new DecodeMandatoryUInt64()); - } - -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt32.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt32.java deleted file mode 100644 index 6ff7e878..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt32.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright 2019-2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.integer; - -import com.exactpro.epfast.decoder.integer.DecodeNullableInt32; -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; - -public class ReadNullableInt32 extends PrimitiveInstruction { - - public ReadNullableInt32() { - super(new DecodeNullableInt32()); - } -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt64.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt64.java deleted file mode 100644 index cf897fe1..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableInt64.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright 2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.integer; - -import com.exactpro.epfast.decoder.integer.DecodeNullableInt64; -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; - -public class ReadNullableInt64 extends PrimitiveInstruction { - - public ReadNullableInt64() { - super(new DecodeNullableInt64()); - } -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt32.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt32.java deleted file mode 100644 index 7cacedaf..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt32.java +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright 2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.integer; - -import com.exactpro.epfast.decoder.integer.DecodeNullableUInt32; -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; - -public class ReadNullableUInt32 extends PrimitiveInstruction { - public ReadNullableUInt32() { - super(new DecodeNullableUInt32()); - } -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt64.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt64.java deleted file mode 100644 index 63e29542..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/integer/ReadNullableUInt64.java +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright 2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.integer; - -import com.exactpro.epfast.decoder.integer.DecodeNullableUInt64; -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; - -public class ReadNullableUInt64 extends PrimitiveInstruction { - public ReadNullableUInt64() { - super(new DecodeNullableUInt64()); - } -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/presencemap/ReadPresenceMap.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/presencemap/ReadPresenceMap.java deleted file mode 100644 index c1be37fe..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/presencemap/ReadPresenceMap.java +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Copyright 2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.presencemap; - -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; -import com.exactpro.epfast.decoder.presencemap.DecodePresenceMap; - -public class ReadPresenceMap extends PrimitiveInstruction { - - public ReadPresenceMap() { - super(new DecodePresenceMap()); - } - -} diff --git a/src/main/java/com/exactpro/epfast/decoder/message/commands/unicode/ReadMandatoryByteVector.java b/src/main/java/com/exactpro/epfast/decoder/message/commands/unicode/ReadMandatoryByteVector.java deleted file mode 100644 index 796d46b3..00000000 --- a/src/main/java/com/exactpro/epfast/decoder/message/commands/unicode/ReadMandatoryByteVector.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright 2020 Exactpro (Exactpro Systems Limited) - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.exactpro.epfast.decoder.message.commands.unicode; - -import com.exactpro.epfast.decoder.message.PrimitiveInstruction; -import com.exactpro.epfast.decoder.unicode.DecodeMandatoryByteVector; - -public class ReadMandatoryByteVector extends PrimitiveInstruction { - - public ReadMandatoryByteVector() { - super(new DecodeMandatoryByteVector()); - } -} From 778ec93c1975b8024bb28c47117438640892c740 Mon Sep 17 00:00:00 2001 From: Anton Sitnikov Date: Wed, 19 Aug 2020 21:09:31 +0400 Subject: [PATCH 14/20] DecodeMandatoryInt32 rework --- .../epfast/decoder/integer/DecodeInteger.java | 23 +++- .../decoder/integer/DecodeMandatoryInt32.java | 122 ++++++++---------- .../decoder/integer/DecodeMandatoryInt64.java | 9 +- .../integer/DecodeMandatoryUInt32.java | 6 +- .../integer/DecodeMandatoryUInt64.java | 7 +- .../decoder/integer/DecodeNullableInt32.java | 9 +- .../decoder/integer/DecodeNullableInt64.java | 9 +- .../decoder/integer/DecodeNullableUInt32.java | 6 +- .../decoder/integer/DecodeNullableUInt64.java | 6 +- 9 files changed, 86 insertions(+), 111 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java index 840bc3c9..d15ed1af 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java @@ -17,11 +17,11 @@ package com.exactpro.epfast.decoder.integer; import com.exactpro.epfast.decoder.IDecodeContext; -import com.exactpro.epfast.decoder.message.UnionRegister; +import io.netty.buffer.ByteBuf; public abstract class DecodeInteger extends IDecodeContext { - static final int SIGN_BIT_MASK = 0b01000000; + protected static final int SIGN_BIT_MASK = 0b01000000; protected boolean ready; @@ -29,23 +29,32 @@ public abstract class DecodeInteger extends IDecodeContext { protected boolean overlong; - boolean checkForSignExtension = false; + protected boolean checkForSignExtension = true; protected boolean inProgress; protected final void reset() { + inProgress = false; ready = false; overflow = false; overlong = false; - checkForSignExtension = false; + checkForSignExtension = true; } - static void longToBytes(long value, byte[] bytes) { + protected final int getByte(ByteBuf buf, int index) { + int oneByte = buf.getByte(index); + if (oneByte < 0) { // if stop bit is set + ready = true; + return oneByte & CLEAR_STOP_BIT_MASK; + } else { + return oneByte; + } + } + + protected static void longToBytes(long value, byte[] bytes) { for (int i = 7; i >= 0; --i) { bytes[i] = (byte) value; value >>>= 8; } } - - public abstract void setResult(UnionRegister register); } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java index 2e3bad0a..bf73a0ee 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java @@ -30,60 +30,28 @@ public final class DecodeMandatoryInt32 extends DecodeInteger { @Override public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (!inProgress) { + int readerLimit = buf.writerIndex(); + if (inProgress) { + if (value >= 0) { + readerIndex = continuePositive(buf, readerIndex, readerLimit); + } else { + readerIndex = continueNegative(buf, readerIndex, readerLimit); + } + } else { inProgress = true; - int oneByte = buf.getByte(readerIndex++); + int oneByte = getByte(buf, readerIndex++); if ((oneByte & SIGN_BIT_MASK) == 0) { value = 0; accumulatePositive(oneByte); - if (oneByte < 0) { - setResult(register); - buf.readerIndex(readerIndex); - return FINISHED; - } - if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex)); //check second byte - do { - accumulatePositive(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; + if (!ready && (readerIndex < readerLimit)) { + readerIndex = continuePositive(buf, readerIndex, readerLimit); } } else { value = -1; accumulateNegative(oneByte); - if (oneByte < 0) { - buf.readerIndex(readerIndex); - setResult(register); - return FINISHED; - } - if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex)); //check second byte - do { - accumulateNegative(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; - } - } - } else { - if (value >= 0) { - if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex)); //continue checking - checkForSignExtension = false; - } - do { - accumulatePositive(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); - } else { - if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes - checkForSignExtension = false; + if (!ready && (readerIndex < readerLimit)) { + readerIndex = continueNegative(buf, readerIndex, readerLimit); } - do { - accumulateNegative(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); } } buf.readerIndex(readerIndex); @@ -95,50 +63,66 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - @Override - public void setResult(UnionRegister register) { - inProgress = false; - register.isOverlong = overlong; - register.isNull = false; - if (overflow) { - register.isOverflow = true; - register.infoMessage = "Int32 Overflow"; - } else { - register.isOverflow = false; - register.int32Value = value; + private int continuePositive(ByteBuf buf, int readerIndex, int readerLimit) { + int oneByte = getByte(buf, readerIndex++); + if (checkForSignExtension) { + checkOverlongPositive(oneByte); + checkForSignExtension = false; } - reset(); + accumulatePositive(oneByte); + while (!ready && (readerIndex < readerLimit)) { + accumulatePositive(getByte(buf, readerIndex++)); + } + return readerIndex; } - private void accumulatePositive(int oneByte) { - if (oneByte < 0) { // if stop bit is set - oneByte &= CLEAR_STOP_BIT_MASK; - ready = true; + private int continueNegative(ByteBuf buf, int readerIndex, int readerLimit) { + int oneByte = getByte(buf, readerIndex++); + if (checkForSignExtension) { + checkOverlongNegative(oneByte); + checkForSignExtension = false; + } + accumulateNegative(oneByte); + while (!ready && (readerIndex < readerLimit)) { + accumulateNegative(getByte(buf, readerIndex++)); } + return readerIndex; + } + + private void accumulatePositive(int oneByte) { if (value <= POSITIVE_LIMIT) { - value = (value << 7) | oneByte; + accumulate(oneByte); } else { overflow = true; } } private void accumulateNegative(int oneByte) { - if (oneByte < 0) { // if stop bit is set - oneByte &= CLEAR_STOP_BIT_MASK; - ready = true; - } if (value >= NEGATIVE_LIMIT) { - value = (value << 7) | oneByte; + accumulate(oneByte); } else { overflow = true; } } + private void accumulate(int oneByte) { + value = (value << 7) | oneByte; + } + private void checkOverlongPositive(int secondByte) { - overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); + overlong = (value == 0) && ((secondByte & SIGN_BIT_MASK) == 0); } private void checkOverlongNegative(int secondByte) { - overlong = value == -1 && ((secondByte & SIGN_BIT_MASK) != 0); + overlong = (value == -1) && ((secondByte & SIGN_BIT_MASK) != 0); + } + + private void setResult(UnionRegister register) { + register.int32Value = value; + register.isNull = false; + register.isOverlong = overlong; + register.isOverflow = overflow; + register.infoMessage = "Int32 Overflow"; + reset(); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java index defeb111..83330ed4 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java @@ -44,11 +44,10 @@ public int decode(ByteBuf buf, UnionRegister register) { } if (readerIndex < readLimit) { checkOverlongPositive(buf.getByte(readerIndex)); //check second byte + checkForSignExtension = false; do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } } else { value = -1; @@ -60,11 +59,10 @@ public int decode(ByteBuf buf, UnionRegister register) { } if (readerIndex < readLimit) { checkOverlongNegative(buf.getByte(readerIndex)); //check second byte + checkForSignExtension = false; do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } } } else { @@ -95,8 +93,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - @Override - public void setResult(UnionRegister register) { + private void setResult(UnionRegister register) { inProgress = false; register.isOverlong = overlong; register.isNull = false; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java index 5f4b9fda..fb355849 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java @@ -41,11 +41,10 @@ public int decode(ByteBuf buf, UnionRegister register) { } if (readerIndex < readLimit) { checkOverlong(buf.getByte(readerIndex)); //check second byte + checkForSignExtension = false; do { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } } else { if (checkForSignExtension) { @@ -65,8 +64,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - @Override - public void setResult(UnionRegister register) { + private void setResult(UnionRegister register) { inProgress = false; register.isOverlong = overlong; register.isNull = false; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java index e4e0178b..85152926 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java @@ -45,11 +45,10 @@ public int decode(ByteBuf buf, UnionRegister register) { } if (readerIndex < readLimit) { checkOverlong(buf.getByte(readerIndex)); //check second byte + checkForSignExtension = false; do { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } } else { if (checkForSignExtension) { @@ -69,8 +68,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - @Override - public void setResult(UnionRegister register) { + private void setResult(UnionRegister register) { inProgress = false; register.isOverlong = overlong; register.isNull = false; @@ -100,5 +98,4 @@ private void accumulate(int oneByte) { private void checkOverlong(int secondByte) { overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } - } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java index 2ea84493..4935f17e 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java @@ -47,11 +47,10 @@ public int decode(ByteBuf buf, UnionRegister register) { } if (readerIndex < readLimit) { checkOverlongPositive(buf.getByte(readerIndex)); //check second byte + checkForSignExtension = false; do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } } else { positive = false; @@ -64,11 +63,10 @@ public int decode(ByteBuf buf, UnionRegister register) { } if (readerIndex < readLimit) { checkOverlongNegative(buf.getByte(readerIndex)); //check second byte + checkForSignExtension = false; do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } } } else { @@ -99,8 +97,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - @Override - public void setResult(UnionRegister register) { + private void setResult(UnionRegister register) { inProgress = false; register.isOverlong = overlong; if (overflow) { diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java index 740c5078..c7ee07e6 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java @@ -47,11 +47,10 @@ public int decode(ByteBuf buf, UnionRegister register) { } if (readerIndex < readLimit) { checkOverlongPositive(buf.getByte(readerIndex)); //check second byte + checkForSignExtension = false; do { accumulatePositive(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } } else { positive = false; @@ -64,11 +63,10 @@ public int decode(ByteBuf buf, UnionRegister register) { } if (readerIndex < readLimit) { checkOverlongNegative(buf.getByte(readerIndex)); //check second byte + checkForSignExtension = false; do { accumulateNegative(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } } } else { @@ -99,8 +97,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - @Override - public void setResult(UnionRegister register) { + private void setResult(UnionRegister register) { inProgress = false; register.isOverlong = overlong; if (overflow) { diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java index dc1e89fe..583e192d 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java @@ -44,11 +44,10 @@ public int decode(ByteBuf buf, UnionRegister register) { } if (readerIndex < readLimit) { checkOverlong(buf.getByte(readerIndex)); //check second byte + checkForSignExtension = false; do { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } } else { if (checkForSignExtension) { @@ -68,8 +67,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - @Override - public void setResult(UnionRegister register) { + private void setResult(UnionRegister register) { inProgress = false; register.isOverlong = overlong; if (overflow) { diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java index a50f9328..89d74bc2 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java @@ -49,11 +49,10 @@ public int decode(ByteBuf buf, UnionRegister register) { } if (readerIndex < readLimit) { checkOverlong(buf.getByte(readerIndex)); //check second byte + checkForSignExtension = false; do { accumulate(buf.getByte(readerIndex++)); } while (!ready && readerIndex < readLimit); - } else { - checkForSignExtension = true; } } else { if (checkForSignExtension) { @@ -73,8 +72,7 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - @Override - public void setResult(UnionRegister register) { + private void setResult(UnionRegister register) { inProgress = false; register.isOverlong = overlong; if (overflow) { From 8d925eca17856fa98c3d4d790008e69a4724cf1c Mon Sep 17 00:00:00 2001 From: Anton Sitnikov Date: Wed, 19 Aug 2020 22:32:02 +0400 Subject: [PATCH 15/20] DecodeMandatoryInt32: inProgress and checkForSignExtension are replaced with bytesRead --- .../epfast/decoder/integer/DecodeInteger.java | 6 ++- .../decoder/integer/DecodeMandatoryInt32.java | 47 +++++++++---------- 2 files changed, 26 insertions(+), 27 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java index d15ed1af..d2b33d62 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java @@ -33,16 +33,20 @@ public abstract class DecodeInteger extends IDecodeContext { protected boolean inProgress; + protected int bytesRead; + protected final void reset() { inProgress = false; + bytesRead = 0; ready = false; overflow = false; overlong = false; checkForSignExtension = true; } - protected final int getByte(ByteBuf buf, int index) { + protected int getByte(ByteBuf buf, int index) { int oneByte = buf.getByte(index); + ++bytesRead; if (oneByte < 0) { // if stop bit is set ready = true; return oneByte & CLEAR_STOP_BIT_MASK; diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java index bf73a0ee..e0c9324d 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt32.java @@ -31,14 +31,7 @@ public final class DecodeMandatoryInt32 extends DecodeInteger { public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); int readerLimit = buf.writerIndex(); - if (inProgress) { - if (value >= 0) { - readerIndex = continuePositive(buf, readerIndex, readerLimit); - } else { - readerIndex = continueNegative(buf, readerIndex, readerLimit); - } - } else { - inProgress = true; + if (bytesRead == 0) { int oneByte = getByte(buf, readerIndex++); if ((oneByte & SIGN_BIT_MASK) == 0) { value = 0; @@ -53,6 +46,12 @@ public int decode(ByteBuf buf, UnionRegister register) { readerIndex = continueNegative(buf, readerIndex, readerLimit); } } + } else { + if (value >= 0) { + readerIndex = continuePositive(buf, readerIndex, readerLimit); + } else { + readerIndex = continueNegative(buf, readerIndex, readerLimit); + } } buf.readerIndex(readerIndex); if (ready) { @@ -64,28 +63,24 @@ public int decode(ByteBuf buf, UnionRegister register) { } private int continuePositive(ByteBuf buf, int readerIndex, int readerLimit) { - int oneByte = getByte(buf, readerIndex++); - if (checkForSignExtension) { - checkOverlongPositive(oneByte); - checkForSignExtension = false; - } - accumulatePositive(oneByte); - while (!ready && (readerIndex < readerLimit)) { - accumulatePositive(getByte(buf, readerIndex++)); - } + do { + int oneByte = getByte(buf, readerIndex++); + if (bytesRead == 2) { + checkOverlongPositive(oneByte); + } + accumulatePositive(oneByte); + } while (!ready && (readerIndex < readerLimit)); return readerIndex; } private int continueNegative(ByteBuf buf, int readerIndex, int readerLimit) { - int oneByte = getByte(buf, readerIndex++); - if (checkForSignExtension) { - checkOverlongNegative(oneByte); - checkForSignExtension = false; - } - accumulateNegative(oneByte); - while (!ready && (readerIndex < readerLimit)) { - accumulateNegative(getByte(buf, readerIndex++)); - } + do { + int oneByte = getByte(buf, readerIndex++); + if (bytesRead == 2) { + checkOverlongNegative(oneByte); + } + accumulateNegative(oneByte); + } while ((!ready && (readerIndex < readerLimit))); return readerIndex; } From 7d932f001eaeb19293ce6b1d740a60d1f965e76c Mon Sep 17 00:00:00 2001 From: vdonadze Date: Thu, 20 Aug 2020 12:03:30 +0400 Subject: [PATCH 16/20] integer classes simplified --- .../decoder/integer/DecodeMandatoryInt64.java | 106 +++++++---------- .../integer/DecodeMandatoryUInt32.java | 62 ++++------ .../integer/DecodeMandatoryUInt64.java | 64 ++++------ .../decoder/integer/DecodeNullableInt32.java | 109 +++++++----------- .../decoder/integer/DecodeNullableInt64.java | 109 +++++++----------- .../decoder/integer/DecodeNullableUInt32.java | 66 ++++------- .../decoder/integer/DecodeNullableUInt64.java | 76 +++++------- .../epfast/decoder/integer/TestInt32.java | 1 - .../epfast/decoder/integer/TestInt64.java | 1 - .../epfast/decoder/integer/TestUInt32.java | 2 - .../epfast/decoder/integer/TestUInt64.java | 1 - 11 files changed, 231 insertions(+), 366 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java index 83330ed4..c6177a6e 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryInt64.java @@ -30,58 +30,27 @@ public final class DecodeMandatoryInt64 extends DecodeInteger { @Override public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (!inProgress) { - inProgress = true; - int oneByte = buf.getByte(readerIndex++); + int readerLimit = buf.writerIndex(); + if (bytesRead == 0) { + int oneByte = getByte(buf, readerIndex++); if ((oneByte & SIGN_BIT_MASK) == 0) { value = 0; accumulatePositive(oneByte); - if (oneByte < 0) { - setResult(register); - buf.readerIndex(readerIndex); - return FINISHED; - } - if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex)); //check second byte - checkForSignExtension = false; - do { - accumulatePositive(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + if (!ready && (readerIndex < readerLimit)) { + readerIndex = continuePositive(buf, readerIndex, readerLimit); } } else { value = -1; accumulateNegative(oneByte); - if (oneByte < 0) { - buf.readerIndex(readerIndex); - setResult(register); - return FINISHED; - } - if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex)); //check second byte - checkForSignExtension = false; - do { - accumulateNegative(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + if (!ready && (readerIndex < readerLimit)) { + readerIndex = continueNegative(buf, readerIndex, readerLimit); } } } else { if (value >= 0) { - if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex)); //continue checking - checkForSignExtension = false; - } - do { - accumulatePositive(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + readerIndex = continuePositive(buf, readerIndex, readerLimit); } else { - if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes - checkForSignExtension = false; - } - do { - accumulateNegative(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + readerIndex = continueNegative(buf, readerIndex, readerLimit); } } buf.readerIndex(readerIndex); @@ -93,44 +62,57 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - private void setResult(UnionRegister register) { - inProgress = false; - register.isOverlong = overlong; - register.isNull = false; - if (overflow) { - register.isOverflow = true; - register.infoMessage = "Int64 Overflow"; - } else { - register.isOverflow = false; - register.int64Value = value; - } - reset(); + private int continuePositive(ByteBuf buf, int readerIndex, int readerLimit) { + do { + int oneByte = getByte(buf, readerIndex++); + if (bytesRead == 2) { + checkOverlongPositive(oneByte); + } + accumulatePositive(oneByte); + } while (!ready && (readerIndex < readerLimit)); + return readerIndex; + } + + private int continueNegative(ByteBuf buf, int readerIndex, int readerLimit) { + do { + int oneByte = getByte(buf, readerIndex++); + if (bytesRead == 2) { + checkOverlongNegative(oneByte); + } + accumulateNegative(oneByte); + } while ((!ready && (readerIndex < readerLimit))); + return readerIndex; } private void accumulatePositive(int oneByte) { - if (oneByte < 0) { // if stop bit is set - oneByte &= CLEAR_STOP_BIT_MASK; - ready = true; - } if (value <= POSITIVE_LIMIT) { - value = (value << 7) | oneByte; + accumulate(oneByte); } else { overflow = true; } } private void accumulateNegative(int oneByte) { - if (oneByte < 0) { // if stop bit is set - oneByte &= CLEAR_STOP_BIT_MASK; - ready = true; - } if (value >= NEGATIVE_LIMIT) { - value = (value << 7) | oneByte; + accumulate(oneByte); } else { overflow = true; } } + private void accumulate(int oneByte) { + value = (value << 7) | oneByte; + } + + private void setResult(UnionRegister register) { + register.int64Value = value; + register.isNull = false; + register.isOverlong = overlong; + register.isOverflow = overflow; + register.infoMessage = "Int64 Overflow"; + reset(); + } + private void checkOverlongPositive(int secondByte) { overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java index fb355849..4ba84024 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt32.java @@ -28,32 +28,16 @@ public final class DecodeMandatoryUInt32 extends DecodeInteger { @Override public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (!inProgress) { + int readerLimit = buf.writerIndex(); + if (bytesRead == 0) { + int oneByte = getByte(buf, readerIndex++); value = 0; - inProgress = true; - int oneByte = buf.getByte(readerIndex++); accumulate(oneByte); - if (oneByte < 0) { - setResult(register); - buf.readerIndex(readerIndex); - return FINISHED; - } - if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex)); //check second byte - checkForSignExtension = false; - do { - accumulate(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + if (!ready && (readerIndex < readerLimit)) { + readerIndex = continuePositive(buf, readerIndex, readerLimit); } } else { - if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex)); //continue checking - checkForSignExtension = false; - } - do { - accumulate(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + readerIndex = continuePositive(buf, readerIndex, readerLimit); } buf.readerIndex(readerIndex); if (ready) { @@ -64,25 +48,18 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - private void setResult(UnionRegister register) { - inProgress = false; - register.isOverlong = overlong; - register.isNull = false; - if (overflow) { - register.isOverflow = true; - register.infoMessage = "UInt32 Overflow"; - } else { - register.isOverflow = false; - register.uInt32Value = value & 0x0_FFFFFFFFL; - } - reset(); + private int continuePositive(ByteBuf buf, int readerIndex, int readerLimit) { + do { + int oneByte = getByte(buf, readerIndex++); + if (bytesRead == 2) { + checkOverlong(oneByte); + } + accumulate(oneByte); + } while (!ready && (readerIndex < readerLimit)); + return readerIndex; } private void accumulate(int oneByte) { - if (oneByte < 0) { // if stop bit is set - oneByte &= CLEAR_STOP_BIT_MASK; - ready = true; - } if ((value & OVERFLOW_MASK) == 0) { value = (value << 7) | oneByte; } else { @@ -90,6 +67,15 @@ private void accumulate(int oneByte) { } } + private void setResult(UnionRegister register) { + register.uInt32Value = value & 0x0_FFFFFFFFL; + register.isNull = false; + register.isOverlong = overlong; + register.isOverflow = overflow; + register.infoMessage = "UInt32 Overflow"; + reset(); + } + private void checkOverlong(int secondByte) { overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java index 85152926..ec65166c 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeMandatoryUInt64.java @@ -32,32 +32,16 @@ public final class DecodeMandatoryUInt64 extends DecodeInteger { @Override public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (!inProgress) { + int readerLimit = buf.writerIndex(); + if (bytesRead == 0) { + int oneByte = getByte(buf, readerIndex++); value = 0; - inProgress = true; - int oneByte = buf.getByte(readerIndex++); accumulate(oneByte); - if (oneByte < 0) { - setResult(register); - buf.readerIndex(readerIndex); - return FINISHED; - } - if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex)); //check second byte - checkForSignExtension = false; - do { - accumulate(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + if (!ready && (readerIndex < readerLimit)) { + readerIndex = continuePositive(buf, readerIndex, readerLimit); } } else { - if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex)); //continue checking - checkForSignExtension = false; - } - do { - accumulate(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + readerIndex = continuePositive(buf, readerIndex, readerLimit); } buf.readerIndex(readerIndex); if (ready) { @@ -68,26 +52,18 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - private void setResult(UnionRegister register) { - inProgress = false; - register.isOverlong = overlong; - register.isNull = false; - if (overflow) { - register.isOverflow = true; - register.infoMessage = "UInt32 Overflow"; - } else { - longToBytes(value, bytes); - register.isOverflow = false; - register.uInt64Value = new BigInteger(1, bytes); - } - reset(); + private int continuePositive(ByteBuf buf, int readerIndex, int readerLimit) { + do { + int oneByte = getByte(buf, readerIndex++); + if (bytesRead == 2) { + checkOverlong(oneByte); + } + accumulate(oneByte); + } while (!ready && (readerIndex < readerLimit)); + return readerIndex; } private void accumulate(int oneByte) { - if (oneByte < 0) { // if stop bit is set - oneByte &= CLEAR_STOP_BIT_MASK; - ready = true; - } if ((value & OVERFLOW_MASK) == 0) { value = (value << 7) | oneByte; } else { @@ -95,6 +71,16 @@ private void accumulate(int oneByte) { } } + private void setResult(UnionRegister register) { + longToBytes(value, bytes); + register.uInt64Value = new BigInteger(1, bytes); + register.isNull = false; + register.isOverlong = overlong; + register.isOverflow = overflow; + register.infoMessage = "UInt64 Overflow"; + reset(); + } + private void checkOverlong(int secondByte) { overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java index 4935f17e..7c5583bd 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt32.java @@ -32,60 +32,29 @@ public final class DecodeNullableInt32 extends DecodeInteger { @Override public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (!inProgress) { - inProgress = true; - int oneByte = buf.getByte(readerIndex++); + int readerLimit = buf.writerIndex(); + if (bytesRead == 0) { + int oneByte = getByte(buf, readerIndex++); if ((oneByte & SIGN_BIT_MASK) == 0) { positive = true; value = 0; accumulatePositive(oneByte); - if (oneByte < 0) { - setResult(register); - buf.readerIndex(readerIndex); - return FINISHED; - } - if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex)); //check second byte - checkForSignExtension = false; - do { - accumulatePositive(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + if (!ready && (readerIndex < readerLimit)) { + readerIndex = continuePositive(buf, readerIndex, readerLimit); } } else { positive = false; value = -1; accumulateNegative(oneByte); - if (oneByte < 0) { - setResult(register); - buf.readerIndex(readerIndex); - return FINISHED; - } - if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex)); //check second byte - checkForSignExtension = false; - do { - accumulateNegative(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + if (!ready && (readerIndex < readerLimit)) { + readerIndex = continueNegative(buf, readerIndex, readerLimit); } } } else { if (value >= 0) { - if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex)); //continue checking - checkForSignExtension = false; - } - do { - accumulatePositive(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + readerIndex = continuePositive(buf, readerIndex, readerLimit); } else { - if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes - checkForSignExtension = false; - } - do { - accumulateNegative(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + readerIndex = continueNegative(buf, readerIndex, readerLimit); } } buf.readerIndex(readerIndex); @@ -97,32 +66,31 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - private void setResult(UnionRegister register) { - inProgress = false; - register.isOverlong = overlong; - if (overflow) { - register.isOverflow = true; - register.isNull = false; - register.infoMessage = "Int32 Overflow"; - } else { - register.isOverflow = false; - if (value == 0) { - register.isNull = true; - } else { - register.isNull = false; - register.int32Value = positive ? value - 1 : value; + private int continuePositive(ByteBuf buf, int readerIndex, int readerLimit) { + do { + int oneByte = getByte(buf, readerIndex++); + if (bytesRead == 2) { + checkOverlongPositive(oneByte); } - } - reset(); + accumulatePositive(oneByte); + } while (!ready && (readerIndex < readerLimit)); + return readerIndex; + } + + private int continueNegative(ByteBuf buf, int readerIndex, int readerLimit) { + do { + int oneByte = getByte(buf, readerIndex++); + if (bytesRead == 2) { + checkOverlongNegative(oneByte); + } + accumulateNegative(oneByte); + } while ((!ready && (readerIndex < readerLimit))); + return readerIndex; } private void accumulatePositive(int oneByte) { - if (oneByte < 0) { // if stop bit is set - oneByte &= CLEAR_STOP_BIT_MASK; - ready = true; - } if (value < POSITIVE_LIMIT) { - value = (value << 7) | oneByte; + accumulate(oneByte); } else if (value == POSITIVE_LIMIT && oneByte == 0 && ready) { value = (value << 7); } else { @@ -131,17 +99,26 @@ private void accumulatePositive(int oneByte) { } private void accumulateNegative(int oneByte) { - if (oneByte < 0) { // if stop bit is set - oneByte &= CLEAR_STOP_BIT_MASK; - ready = true; - } if (value >= NEGATIVE_LIMIT) { - value = (value << 7) | oneByte; + accumulate(oneByte); } else { overflow = true; } } + private void accumulate(int oneByte) { + value = (value << 7) | oneByte; + } + + private void setResult(UnionRegister register) { + register.int32Value = positive ? value - 1 : value; + register.isNull = value == 0; + register.isOverlong = overlong; + register.isOverflow = overflow; + register.infoMessage = "Int32 Overflow"; + reset(); + } + private void checkOverlongPositive(int secondByte) { overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java index c7ee07e6..d2fd5241 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableInt64.java @@ -32,60 +32,29 @@ public final class DecodeNullableInt64 extends DecodeInteger { @Override public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (!inProgress) { - inProgress = true; - int oneByte = buf.getByte(readerIndex++); + int readerLimit = buf.writerIndex(); + if (bytesRead == 0) { + int oneByte = getByte(buf, readerIndex++); if ((oneByte & SIGN_BIT_MASK) == 0) { positive = true; value = 0; accumulatePositive(oneByte); - if (oneByte < 0) { - setResult(register); - buf.readerIndex(readerIndex); - return FINISHED; - } - if (readerIndex < readLimit) { - checkOverlongPositive(buf.getByte(readerIndex)); //check second byte - checkForSignExtension = false; - do { - accumulatePositive(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + if (!ready && (readerIndex < readerLimit)) { + readerIndex = continuePositive(buf, readerIndex, readerLimit); } } else { positive = false; value = -1; accumulateNegative(oneByte); - if (oneByte < 0) { - setResult(register); - buf.readerIndex(readerIndex); - return FINISHED; - } - if (readerIndex < readLimit) { - checkOverlongNegative(buf.getByte(readerIndex)); //check second byte - checkForSignExtension = false; - do { - accumulateNegative(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + if (!ready && (readerIndex < readerLimit)) { + readerIndex = continueNegative(buf, readerIndex, readerLimit); } } } else { if (value >= 0) { - if (checkForSignExtension) { - checkOverlongPositive(buf.getByte(readerIndex)); //continue checking - checkForSignExtension = false; - } - do { - accumulatePositive(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + readerIndex = continuePositive(buf, readerIndex, readerLimit); } else { - if (checkForSignExtension) { - checkOverlongNegative(buf.getByte(readerIndex)); //check first and second bytes - checkForSignExtension = false; - } - do { - accumulateNegative(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + readerIndex = continueNegative(buf, readerIndex, readerLimit); } } buf.readerIndex(readerIndex); @@ -97,32 +66,31 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - private void setResult(UnionRegister register) { - inProgress = false; - register.isOverlong = overlong; - if (overflow) { - register.isOverflow = true; - register.isNull = false; - register.infoMessage = "Int64 Overflow"; - } else { - register.isOverflow = false; - if (value == 0) { - register.isNull = true; - } else { - register.isNull = false; - register.int64Value = positive ? value - 1 : value; + private int continuePositive(ByteBuf buf, int readerIndex, int readerLimit) { + do { + int oneByte = getByte(buf, readerIndex++); + if (bytesRead == 2) { + checkOverlongPositive(oneByte); } - } - reset(); + accumulatePositive(oneByte); + } while (!ready && (readerIndex < readerLimit)); + return readerIndex; + } + + private int continueNegative(ByteBuf buf, int readerIndex, int readerLimit) { + do { + int oneByte = getByte(buf, readerIndex++); + if (bytesRead == 2) { + checkOverlongNegative(oneByte); + } + accumulateNegative(oneByte); + } while ((!ready && (readerIndex < readerLimit))); + return readerIndex; } private void accumulatePositive(int oneByte) { - if (oneByte < 0) { // if stop bit is set - oneByte &= CLEAR_STOP_BIT_MASK; - ready = true; - } if (value < POSITIVE_LIMIT) { - value = (value << 7) | oneByte; + accumulate(oneByte); } else if (value == POSITIVE_LIMIT && oneByte == 0 && ready) { value = (value << 7); } else { @@ -131,17 +99,26 @@ private void accumulatePositive(int oneByte) { } private void accumulateNegative(int oneByte) { - if (oneByte < 0) { // if stop bit is set - oneByte &= CLEAR_STOP_BIT_MASK; - ready = true; - } if (value >= NEGATIVE_LIMIT) { - value = (value << 7) | oneByte; + accumulate(oneByte); } else { overflow = true; } } + private void accumulate(int oneByte) { + value = (value << 7) | oneByte; + } + + private void setResult(UnionRegister register) { + register.int64Value = positive ? value - 1 : value; + register.isNull = value == 0; + register.isOverlong = overlong; + register.isOverflow = overflow; + register.infoMessage = "Int64 Overflow"; + reset(); + } + private void checkOverlongPositive(int secondByte) { overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java index 583e192d..c772444f 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt32.java @@ -30,33 +30,17 @@ public final class DecodeNullableUInt32 extends DecodeInteger { @Override public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (!inProgress) { + int readerLimit = buf.writerIndex(); + if (bytesRead == 0) { + int oneByte = getByte(buf, readerIndex++); value = 0; isUInt32Limit = false; - inProgress = true; - int oneByte = buf.getByte(readerIndex++); accumulate(oneByte); - if (oneByte < 0) { - setResult(register); - buf.readerIndex(readerIndex); - return FINISHED; - } - if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex)); //check second byte - checkForSignExtension = false; - do { - accumulate(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + if (!ready && (readerIndex < readerLimit)) { + readerIndex = continuePositive(buf, readerIndex, readerLimit); } } else { - if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex)); //continue checking - checkForSignExtension = false; - } - do { - accumulate(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + readerIndex = continuePositive(buf, readerIndex, readerLimit); } buf.readerIndex(readerIndex); if (ready) { @@ -67,29 +51,18 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - private void setResult(UnionRegister register) { - inProgress = false; - register.isOverlong = overlong; - if (overflow) { - register.isOverflow = true; - register.isNull = false; - register.infoMessage = "UInt32 Overflow"; - } else if (value == 0) { - register.isOverflow = false; - register.isNull = true; - } else { - register.isOverflow = false; - register.isNull = false; - register.uInt32Value = isUInt32Limit ? 0x0_FFFFFFFFL : value - 1 & 0x0_FFFFFFFFL; - } - reset(); + private int continuePositive(ByteBuf buf, int readerIndex, int readerLimit) { + do { + int oneByte = getByte(buf, readerIndex++); + if (bytesRead == 2) { + checkOverlong(oneByte); + } + accumulate(oneByte); + } while (!ready && (readerIndex < readerLimit)); + return readerIndex; } private void accumulate(int oneByte) { - if (oneByte < 0) { // if stop bit is set - oneByte &= CLEAR_STOP_BIT_MASK; - ready = true; - } if (value < POSITIVE_LIMIT) { value = (value << 7) | oneByte; } else if (value == POSITIVE_LIMIT && oneByte == 0 && ready) { @@ -99,6 +72,15 @@ private void accumulate(int oneByte) { } } + private void setResult(UnionRegister register) { + register.uInt32Value = isUInt32Limit ? 0x0_FFFFFFFFL : value - 1 & 0x0_FFFFFFFFL; + register.isNull = value == 0; + register.isOverlong = overlong; + register.isOverflow = overflow; + register.infoMessage = "UInt32 Overflow"; + reset(); + } + private void checkOverlong(int secondByte) { overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java index 89d74bc2..0e2c7a91 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeNullableUInt64.java @@ -34,34 +34,17 @@ public final class DecodeNullableUInt64 extends DecodeInteger { @Override public int decode(ByteBuf buf, UnionRegister register) { int readerIndex = buf.readerIndex(); - int readLimit = buf.writerIndex(); - if (!inProgress) { + int readerLimit = buf.writerIndex(); + if (bytesRead == 0) { + int oneByte = getByte(buf, readerIndex++); value = 0; isUInt64Limit = false; - inProgress = true; - - int oneByte = buf.getByte(readerIndex++); accumulate(oneByte); - if (oneByte < 0) { - setResult(register); - buf.readerIndex(readerIndex); - return FINISHED; - } - if (readerIndex < readLimit) { - checkOverlong(buf.getByte(readerIndex)); //check second byte - checkForSignExtension = false; - do { - accumulate(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + if (!ready && (readerIndex < readerLimit)) { + readerIndex = continuePositive(buf, readerIndex, readerLimit); } } else { - if (checkForSignExtension) { - checkOverlong(buf.getByte(readerIndex)); //continue checking - checkForSignExtension = false; - } - do { - accumulate(buf.getByte(readerIndex++)); - } while (!ready && readerIndex < readLimit); + readerIndex = continuePositive(buf, readerIndex, readerLimit); } buf.readerIndex(readerIndex); if (ready) { @@ -72,35 +55,18 @@ public int decode(ByteBuf buf, UnionRegister register) { } } - private void setResult(UnionRegister register) { - inProgress = false; - register.isOverlong = overlong; - if (overflow) { - register.isOverflow = true; - register.isNull = false; - register.infoMessage = "UInt64 Overflow"; - } else if (value == 0) { - register.isOverflow = false; - register.isNull = true; - register.uInt64Value = null; - } else { - register.isOverflow = false; - register.isNull = false; - if (isUInt64Limit) { - longToBytes(-1L, bytes); - } else { - longToBytes(value - 1, bytes); + private int continuePositive(ByteBuf buf, int readerIndex, int readerLimit) { + do { + int oneByte = getByte(buf, readerIndex++); + if (bytesRead == 2) { + checkOverlong(oneByte); } - register.uInt64Value = new BigInteger(1, bytes); - } - reset(); + accumulate(oneByte); + } while (!ready && (readerIndex < readerLimit)); + return readerIndex; } private void accumulate(int oneByte) { - if (oneByte < 0) { // if stop bit is set - oneByte &= CLEAR_STOP_BIT_MASK; - ready = true; - } if (value < POSITIVE_LIMIT) { value = (value << 7) | oneByte; } else if (value == POSITIVE_LIMIT && oneByte == 0 && ready) { @@ -110,6 +76,20 @@ private void accumulate(int oneByte) { } } + private void setResult(UnionRegister register) { + if (isUInt64Limit) { + longToBytes(-1L, bytes); + } else { + longToBytes(value - 1, bytes); + } + register.uInt64Value = new BigInteger(1, bytes); + register.isNull = value == 0; + register.isOverlong = overlong; + register.isOverflow = overflow; + register.infoMessage = "UInt64 Overflow"; + reset(); + } + private void checkOverlong(int secondByte) { overlong = value == 0 && ((secondByte & SIGN_BIT_MASK) == 0); } diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java index c1e0e037..6551bd95 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java @@ -43,7 +43,6 @@ void testNull(Collection buffers) { assertTrue(decodeResult.isNull); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isOverlong); - assertEquals(decodeResult.int32Value, -999); } @WithByteBuf("81") diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java index 70286238..8ff6d4ce 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java @@ -42,7 +42,6 @@ void testNull(Collection buffers) { assertTrue(decodeResult.isNull); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isOverlong); - assertEquals(decodeResult.int64Value, -999); } @WithByteBuf("81") diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java index e77df942..d8970594 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java @@ -42,8 +42,6 @@ void testNull(Collection buffers) { assertTrue(decodeResult.isNull); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isOverlong); - assertEquals(-999, decodeResult.uInt32Value); - } @WithByteBuf("81") diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java index 6b115c3d..72d17ecf 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java @@ -44,7 +44,6 @@ void testNull(Collection buffers) { assertTrue(decodeResult.isNull); assertFalse(decodeResult.isOverflow); assertFalse(decodeResult.isOverlong); - assertNull(decodeResult.uInt64Value); } @WithByteBuf("81") From 55a2df5e94f6c61e7c06459ebf071db7a2e91f4c Mon Sep 17 00:00:00 2001 From: vdonadze Date: Thu, 20 Aug 2020 12:04:44 +0400 Subject: [PATCH 17/20] removed inProgress flag --- .../com/exactpro/epfast/decoder/integer/DecodeInteger.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java index d2b33d62..48680e12 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java @@ -31,12 +31,9 @@ public abstract class DecodeInteger extends IDecodeContext { protected boolean checkForSignExtension = true; - protected boolean inProgress; - protected int bytesRead; protected final void reset() { - inProgress = false; bytesRead = 0; ready = false; overflow = false; From 6fed79d6cb6e25a8225be82815530b596e2fd331 Mon Sep 17 00:00:00 2001 From: vdonadze Date: Thu, 20 Aug 2020 13:21:05 +0400 Subject: [PATCH 18/20] simplify setResults for strings --- .../epfast/decoder/ascii/DecodeMandatoryAsciiString.java | 7 ++----- .../epfast/decoder/ascii/DecodeNullableAsciiString.java | 8 ++------ 2 files changed, 4 insertions(+), 11 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java index 86962732..7bad1445 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeMandatoryAsciiString.java @@ -37,18 +37,15 @@ public void setResult(UnionRegister register) { register.infoMessage = "String is longer than allowed"; } else if (zeroCount < stringBuilder.length()) { register.isNull = false; + register.isOverflow = false; + register.isOverlong = false; if ((zeroCount > 1) && checkOverlong) { - register.isOverflow = false; - register.isOverlong = false; register.stringValue = stringBuilder.substring(1); } else if (zeroCount == 1) { - register.isOverflow = false; register.isOverlong = true; register.infoMessage = "String is overlong if first 7 bits after zero preamble are not \\0"; register.stringValue = stringBuilder.substring(1); } else { - register.isOverflow = false; - register.isOverlong = false; register.stringValue = stringBuilder.toString(); } } else { diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java index e46587a2..059c4b97 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeNullableAsciiString.java @@ -37,23 +37,19 @@ public void setResult(UnionRegister register) { register.infoMessage = "String is longer than allowed"; } else if (zeroCount < stringBuilder.length()) { register.isNull = false; + register.isOverflow = false; + register.isOverlong = false; if ((zeroCount > 2) && checkOverlong) { - register.isOverflow = false; - register.isOverlong = false; register.stringValue = stringBuilder.substring(2); } else if ((zeroCount == 1) && checkOverlong) { - register.isOverflow = false; register.isOverlong = true; register.infoMessage = "String is overlong if first 7 bits after zero preamble are not \\0"; register.stringValue = stringBuilder.substring(1); } else if ((zeroCount == 2) && checkOverlong) { - register.isOverflow = false; register.isOverlong = true; register.infoMessage = "String is overlong if first 7 bits after zero preamble are not \\0"; register.stringValue = stringBuilder.substring(2); } else { - register.isOverflow = false; - register.isOverlong = false; register.stringValue = stringBuilder.toString(); } } else if (zeroCount == 1) { From 3ec9a3afd27194fe2b90f487af683fd8056d6a89 Mon Sep 17 00:00:00 2001 From: Anton Sitnikov Date: Thu, 20 Aug 2020 17:33:03 +0400 Subject: [PATCH 19/20] Some renames and removal of unused fields --- .../{IDecodeContext.java => StreamDecoderCommand.java} | 8 ++++---- .../exactpro/epfast/decoder/ascii/DecodeAsciiString.java | 4 ++-- .../exactpro/epfast/decoder/decimal/DecodeDecimal.java | 4 ++-- .../exactpro/epfast/decoder/integer/DecodeInteger.java | 7 ++----- .../epfast/decoder/presencemap/DecodePresenceMap.java | 4 ++-- .../exactpro/epfast/decoder/unicode/DecodeByteVector.java | 4 ++-- .../com/exactpro/epfast/{ => decoder}/DecoderUtils.java | 7 +++---- .../epfast/decoder/ascii/TestDecodeAsciiString.java | 2 +- .../epfast/decoder/decimal/TestDecodeDecimal.java | 2 +- .../com/exactpro/epfast/decoder/integer/TestInt32.java | 2 +- .../com/exactpro/epfast/decoder/integer/TestInt64.java | 2 +- .../com/exactpro/epfast/decoder/integer/TestUInt32.java | 2 +- .../com/exactpro/epfast/decoder/integer/TestUInt64.java | 2 +- .../epfast/decoder/presencemap/TestDecodePresenceMap.java | 2 +- .../epfast/decoder/unicode/TestDecodeByteVector.java | 2 +- 15 files changed, 25 insertions(+), 29 deletions(-) rename src/main/java/com/exactpro/epfast/decoder/{IDecodeContext.java => StreamDecoderCommand.java} (84%) rename src/test/java/com/exactpro/epfast/{ => decoder}/DecoderUtils.java (84%) diff --git a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java b/src/main/java/com/exactpro/epfast/decoder/StreamDecoderCommand.java similarity index 84% rename from src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java rename to src/main/java/com/exactpro/epfast/decoder/StreamDecoderCommand.java index 7a0b65d1..16a2a523 100644 --- a/src/main/java/com/exactpro/epfast/decoder/IDecodeContext.java +++ b/src/main/java/com/exactpro/epfast/decoder/StreamDecoderCommand.java @@ -21,21 +21,21 @@ import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; -public abstract class IDecodeContext implements DecoderCommand { +public abstract class StreamDecoderCommand implements DecoderCommand { - protected static final int FINISHED = 1; + public static final int FINISHED = 1; public static final int MORE_DATA_NEEDED = 0; protected static final int CLEAR_STOP_BIT_MASK = 0b01111111; - public abstract int decode(ByteBuf buf, UnionRegister register); + protected abstract int decode(ByteBuf buf, UnionRegister register); @Override public int executeOn(DecoderState decoderState) { if (!decoderState.inputBuffer.isReadable()) { decoderState.canProceed = false; - return 0; + return MORE_DATA_NEEDED; } return decode(decoderState.inputBuffer, decoderState.register); } diff --git a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java index 5bb38004..781badba 100644 --- a/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java +++ b/src/main/java/com/exactpro/epfast/decoder/ascii/DecodeAsciiString.java @@ -16,11 +16,11 @@ package com.exactpro.epfast.decoder.ascii; -import com.exactpro.epfast.decoder.IDecodeContext; +import com.exactpro.epfast.decoder.StreamDecoderCommand; import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; -public abstract class DecodeAsciiString extends IDecodeContext { +public abstract class DecodeAsciiString extends StreamDecoderCommand { final StringBuilder stringBuilder = new StringBuilder(); diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java index c34ca5e4..7891a503 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeDecimal.java @@ -16,11 +16,11 @@ package com.exactpro.epfast.decoder.decimal; -import com.exactpro.epfast.decoder.IDecodeContext; +import com.exactpro.epfast.decoder.StreamDecoderCommand; import com.exactpro.epfast.decoder.integer.DecodeMandatoryInt64; import com.exactpro.epfast.decoder.message.UnionRegister; -public abstract class DecodeDecimal extends IDecodeContext { +public abstract class DecodeDecimal extends StreamDecoderCommand { DecodeMandatoryInt64 mantissaDecoder = new DecodeMandatoryInt64(); diff --git a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java index 48680e12..642d0b26 100644 --- a/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java +++ b/src/main/java/com/exactpro/epfast/decoder/integer/DecodeInteger.java @@ -16,10 +16,10 @@ package com.exactpro.epfast.decoder.integer; -import com.exactpro.epfast.decoder.IDecodeContext; +import com.exactpro.epfast.decoder.StreamDecoderCommand; import io.netty.buffer.ByteBuf; -public abstract class DecodeInteger extends IDecodeContext { +public abstract class DecodeInteger extends StreamDecoderCommand { protected static final int SIGN_BIT_MASK = 0b01000000; @@ -29,8 +29,6 @@ public abstract class DecodeInteger extends IDecodeContext { protected boolean overlong; - protected boolean checkForSignExtension = true; - protected int bytesRead; protected final void reset() { @@ -38,7 +36,6 @@ protected final void reset() { ready = false; overflow = false; overlong = false; - checkForSignExtension = true; } protected int getByte(ByteBuf buf, int index) { diff --git a/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java b/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java index a4e62e65..95acf01c 100644 --- a/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java +++ b/src/main/java/com/exactpro/epfast/decoder/presencemap/DecodePresenceMap.java @@ -16,13 +16,13 @@ package com.exactpro.epfast.decoder.presencemap; -import com.exactpro.epfast.decoder.IDecodeContext; +import com.exactpro.epfast.decoder.StreamDecoderCommand; import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; import java.util.BitSet; -public class DecodePresenceMap extends IDecodeContext { +public class DecodePresenceMap extends StreamDecoderCommand { private BitSet value = new BitSet(); diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java index e15ed37e..fe3e180b 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeByteVector.java @@ -16,13 +16,13 @@ package com.exactpro.epfast.decoder.unicode; -import com.exactpro.epfast.decoder.IDecodeContext; +import com.exactpro.epfast.decoder.StreamDecoderCommand; import com.exactpro.epfast.decoder.message.UnionRegister; import java.util.ArrayList; import java.util.List; -public abstract class DecodeByteVector extends IDecodeContext { +public abstract class DecodeByteVector extends StreamDecoderCommand { List value = new ArrayList<>(); diff --git a/src/test/java/com/exactpro/epfast/DecoderUtils.java b/src/test/java/com/exactpro/epfast/decoder/DecoderUtils.java similarity index 84% rename from src/test/java/com/exactpro/epfast/DecoderUtils.java rename to src/test/java/com/exactpro/epfast/decoder/DecoderUtils.java index f8b3ed2a..055cb411 100644 --- a/src/test/java/com/exactpro/epfast/DecoderUtils.java +++ b/src/test/java/com/exactpro/epfast/decoder/DecoderUtils.java @@ -14,9 +14,8 @@ * limitations under the License. */ -package com.exactpro.epfast; +package com.exactpro.epfast.decoder; -import com.exactpro.epfast.decoder.IDecodeContext; import com.exactpro.epfast.decoder.message.UnionRegister; import io.netty.buffer.ByteBuf; @@ -24,9 +23,9 @@ public class DecoderUtils { - public static void decode(IDecodeContext decoder, Iterable buffers, UnionRegister register) { + public static void decode(StreamDecoderCommand decoder, Iterable buffers, UnionRegister register) { Iterator it = buffers.iterator(); - while (decoder.decode(nextNonEmptyBuffer(it), register) == IDecodeContext.MORE_DATA_NEEDED) { + while (decoder.decode(nextNonEmptyBuffer(it), register) == StreamDecoderCommand.MORE_DATA_NEEDED) { } } diff --git a/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java b/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java index 821099ab..c6d12dcb 100644 --- a/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java +++ b/src/test/java/com/exactpro/epfast/decoder/ascii/TestDecodeAsciiString.java @@ -28,7 +28,7 @@ import static org.junit.jupiter.api.Assertions.*; import static com.exactpro.junit5.ByteBufUtils.*; -import static com.exactpro.epfast.DecoderUtils.*; +import static com.exactpro.epfast.decoder.DecoderUtils.*; class TestDecodeAsciiString { diff --git a/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java b/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java index e10c648a..4e4d1b02 100644 --- a/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java +++ b/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java @@ -25,7 +25,7 @@ import org.junit.jupiter.api.BeforeEach; import static org.junit.jupiter.api.Assertions.*; -import static com.exactpro.epfast.DecoderUtils.*; +import static com.exactpro.epfast.decoder.DecoderUtils.*; import static org.junit.jupiter.api.Assertions.assertFalse; class TestDecodeDecimal { diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java index 6551bd95..752c9e94 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt32.java @@ -25,7 +25,7 @@ import java.util.Collection; import static org.junit.jupiter.api.Assertions.*; -import static com.exactpro.epfast.DecoderUtils.*; +import static com.exactpro.epfast.decoder.DecoderUtils.*; class TestInt32 { diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java index 8ff6d4ce..eb75fb8c 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestInt64.java @@ -24,7 +24,7 @@ import java.util.Collection; import static org.junit.jupiter.api.Assertions.*; -import static com.exactpro.epfast.DecoderUtils.*; +import static com.exactpro.epfast.decoder.DecoderUtils.*; class TestInt64 { diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java index d8970594..88545dea 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt32.java @@ -24,7 +24,7 @@ import java.util.Collection; import static org.junit.jupiter.api.Assertions.*; -import static com.exactpro.epfast.DecoderUtils.*; +import static com.exactpro.epfast.decoder.DecoderUtils.*; class TestUInt32 { diff --git a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java index 72d17ecf..b8bb01e4 100644 --- a/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java +++ b/src/test/java/com/exactpro/epfast/decoder/integer/TestUInt64.java @@ -25,7 +25,7 @@ import java.util.Collection; import static org.junit.jupiter.api.Assertions.*; -import static com.exactpro.epfast.DecoderUtils.*; +import static com.exactpro.epfast.decoder.DecoderUtils.*; class TestUInt64 { diff --git a/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java b/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java index 226042b4..a17a5d9b 100644 --- a/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java +++ b/src/test/java/com/exactpro/epfast/decoder/presencemap/TestDecodePresenceMap.java @@ -23,7 +23,7 @@ import java.util.Collection; -import static com.exactpro.epfast.DecoderUtils.decode; +import static com.exactpro.epfast.decoder.DecoderUtils.decode; import static org.junit.jupiter.api.Assertions.*; class TestDecodePresenceMap { diff --git a/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java b/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java index fdc257fb..dfadf995 100644 --- a/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java +++ b/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java @@ -25,7 +25,7 @@ import java.util.Collection; import static org.junit.jupiter.api.Assertions.*; -import static com.exactpro.epfast.DecoderUtils.*; +import static com.exactpro.epfast.decoder.DecoderUtils.*; class TestDecodeByteVector { From d7d02f2d5c971002a0608c08c033f63d3c008b51 Mon Sep 17 00:00:00 2001 From: vdonadze Date: Thu, 20 Aug 2020 18:54:54 +0400 Subject: [PATCH 20/20] simplify setResults --- .../decimal/DecodeMandatoryDecimal.java | 8 +------ .../decimal/DecodeNullableDecimal.java | 14 +------------ .../unicode/DecodeMandatoryByteVector.java | 18 ++++++---------- .../unicode/DecodeNullableByteVector.java | 21 ++++++------------- .../decoder/decimal/TestDecodeDecimal.java | 1 - .../decoder/unicode/TestDecodeByteVector.java | 1 - 6 files changed, 14 insertions(+), 49 deletions(-) diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java index 4c8f18b2..2d230256 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeMandatoryDecimal.java @@ -75,21 +75,15 @@ public int decode(ByteBuf buf, UnionRegister register) { public void setResult(UnionRegister register) { register.isOverlong = exponentOverlong || mantissaOverlong; + register.isOverflow = exponentOverflow || mantissaOverflow; if (exponentOverflow) { - register.isOverflow = true; - register.isNull = false; register.infoMessage = "exponent value range is int32"; } else if (mantissaOverflow) { - register.isOverflow = true; - register.isNull = false; register.infoMessage = "mantissa value range is int64"; } else if (exponent >= -63 && exponent <= 63) { - register.isOverflow = false; - register.isNull = false; register.decimalValue = new BigDecimal(mantissa).movePointRight(exponent); } else { register.isOverflow = true; - register.isNull = false; register.infoMessage = "exponent value allowed range is -63 ... 63"; } reset(); diff --git a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java index 5308af96..66f4fbae 100644 --- a/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java +++ b/src/main/java/com/exactpro/epfast/decoder/decimal/DecodeNullableDecimal.java @@ -28,8 +28,6 @@ public final class DecodeNullableDecimal extends DecodeDecimal { private int exponent; - private boolean nullValue; - @Override public int decode(ByteBuf buf, UnionRegister register) { if (!exponentReady) { @@ -58,7 +56,6 @@ public int decode(ByteBuf buf, UnionRegister register) { return FINISHED; } } else if (register.isNull) { - nullValue = true; ready = true; setResult(register); return FINISHED; @@ -83,24 +80,15 @@ public int decode(ByteBuf buf, UnionRegister register) { @Override public void setResult(UnionRegister register) { register.isOverlong = exponentOverlong || mantissaOverlong; + register.isOverflow = exponentOverflow || mantissaOverflow; if (exponentOverflow) { - register.isOverflow = true; - register.isNull = false; register.infoMessage = "exponent value range is int32"; } else if (mantissaOverflow) { - register.isOverflow = true; - register.isNull = false; register.infoMessage = "mantissa value range is int64"; - } else if (nullValue) { - register.isOverflow = false; - register.decimalValue = null; } else if (exponent >= -63 && exponent <= 63) { - register.isOverflow = false; - register.isNull = false; register.decimalValue = new BigDecimal(mantissa).movePointRight(exponent); } else { register.isOverflow = true; - register.isNull = false; register.infoMessage = "exponent value allowed range is -63 ... 63"; } reset(); diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java index 0624fd3e..62952f5f 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeMandatoryByteVector.java @@ -80,19 +80,13 @@ public int decode(ByteBuf buf, UnionRegister register) { @Override public void setResult(UnionRegister register) { - if (overflow) { - register.isOverflow = true; - register.isNull = false; - register.infoMessage = "length value range is uint32"; - } else { - byte[] finalVal = new byte[value.size()]; - for (int i = 0; i < value.size(); i++) { - finalVal[i] = value.get(i); - } - register.isOverflow = false; - register.isNull = false; - register.byteVectorValue = finalVal; + register.isOverflow = overflow; + register.infoMessage = "length value range is uint32"; + byte[] finalVal = new byte[value.size()]; + for (int i = 0; i < value.size(); i++) { + finalVal[i] = value.get(i); } + register.byteVectorValue = finalVal; reset(); } } diff --git a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java index 710cebc3..ba666792 100644 --- a/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java +++ b/src/main/java/com/exactpro/epfast/decoder/unicode/DecodeNullableByteVector.java @@ -80,22 +80,13 @@ public int decode(ByteBuf buf, UnionRegister register) { @Override public void setResult(UnionRegister register) { - if (overflow) { - register.isOverflow = true; - register.isNull = false; - register.infoMessage = "length value range is uint32"; - } else { - byte[] finalVal = new byte[value.size()]; - for (int i = 0; i < value.size(); i++) { - finalVal[i] = value.get(i); - } - register.isOverflow = false; - if (register.isNull) { - register.byteVectorValue = null; - } else { - register.byteVectorValue = finalVal; - } + register.isOverflow = overflow; + register.infoMessage = "length value range is uint32"; + byte[] finalVal = new byte[value.size()]; + for (int i = 0; i < value.size(); i++) { + finalVal[i] = value.get(i); } + register.byteVectorValue = finalVal; reset(); } } diff --git a/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java b/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java index 4e4d1b02..8bd0630f 100644 --- a/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java +++ b/src/test/java/com/exactpro/epfast/decoder/decimal/TestDecodeDecimal.java @@ -45,7 +45,6 @@ void testNull(Collection buffers) { assertFalse(decodeResult.isOverlong); assertFalse(decodeResult.isOverflow); assertTrue(decodeResult.isNull); - assertNull(decodeResult.decimalValue); } @WithByteBuf("83 39 45 a3") diff --git a/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java b/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java index dfadf995..3b627fa5 100644 --- a/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java +++ b/src/test/java/com/exactpro/epfast/decoder/unicode/TestDecodeByteVector.java @@ -42,7 +42,6 @@ void testNull(Collection buffers) { decode(nullableByteVectorDecoder, buffers, decodeResult); assertTrue(decodeResult.isNull); assertFalse(decodeResult.isOverflow); - assertNull(decodeResult.byteVectorValue); } @WithByteBuf("81")