diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java index 3db45077..f2d7e4c9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java @@ -38,7 +38,10 @@ public BigIntegerAddModification createCopy() { @Override protected BigInteger modifyImplementationHook(BigInteger input) { - return input == null ? summand : input.add(summand); + if (input == null) { + return null; + } + return input.add(summand); } public BigInteger getSummand() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java index 712847bf..df12ae11 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java @@ -39,7 +39,7 @@ public BigIntegerExplicitValueModification createCopy() { @Override protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { - throw new NullPointerException("original value must not be null"); + return null; } return explicitValue; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java index f7918b32..d51e29e7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java @@ -38,7 +38,10 @@ public BigIntegerMultiplyModification createCopy() { @Override protected BigInteger modifyImplementationHook(BigInteger input) { - return input == null ? BigInteger.ZERO : input.multiply(factor); + if (input == null) { + return null; + } + return input.multiply(factor); } public BigInteger getFactor() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java index 21695d78..c8b447d2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java @@ -38,7 +38,7 @@ public BigIntegerShiftLeftModification createCopy() { @Override protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { - input = BigInteger.ZERO; + return null; } return input.shiftLeft(shift); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java index 3845d3f8..41f9b6d4 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java @@ -38,7 +38,7 @@ public BigIntegerShiftRightModification createCopy() { @Override protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { - input = BigInteger.ZERO; + return null; } return input.shiftRight(shift); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java index 356463b8..99c09761 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java @@ -39,7 +39,7 @@ public BigIntegerSubtractModification createCopy() { @Override protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { - input = BigInteger.ZERO; + return null; } return input.subtract(subtrahend); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java index 10d79b3a..74c455a2 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java @@ -39,7 +39,7 @@ public BigIntegerXorModification createCopy() { @Override protected BigInteger modifyImplementationHook(BigInteger input) { if (input == null) { - input = BigInteger.ZERO; + return null; } return input.xor(xor); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java index 79416d75..01f1625a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java @@ -37,7 +37,7 @@ public BooleanExplicitValueModification createCopy() { @Override protected Boolean modifyImplementationHook(Boolean input) { if (input == null) { - throw new NullPointerException("original value must not be null"); + return null; } return explicitValue; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java index cfd0c0ca..4f832979 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java @@ -28,6 +28,9 @@ public BooleanToggleModification createCopy() { @Override protected Boolean modifyImplementationHook(Boolean input) { + if (input == null) { + return null; + } return !input; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java index 9317f237..25a7c8df 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayAppendValueModification.java @@ -41,6 +41,9 @@ public ByteArrayAppendValueModification createCopy() { @Override protected byte[] modifyImplementationHook(byte[] input) { + if (input == null) { + return null; + } return ArrayConverter.concatenate(input, bytesToAppend); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java index 10d70c67..8e41844b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java @@ -42,6 +42,9 @@ public ByteArrayDeleteModification createCopy() { @Override protected byte[] modifyImplementationHook(byte[] input) { + if (input == null) { + return null; + } if (input.length == 0) { return input; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java index c8f13fda..a11c806d 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java @@ -30,7 +30,7 @@ public ByteArrayDuplicateModification createCopy() { @Override protected byte[] modifyImplementationHook(byte[] input) { if (input == null) { - input = new byte[0]; + return null; } return ArrayConverter.concatenate(input, input); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java index bba2ca8e..3ec57152 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java @@ -42,7 +42,7 @@ public ByteArrayExplicitValueModification createCopy() { @Override protected byte[] modifyImplementationHook(byte[] input) { if (input == null) { - throw new NullPointerException("original value must not be null"); + return null; } return explicitValue.clone(); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java index d07e76cf..88ea912f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertValueModification.java @@ -46,9 +46,8 @@ public ByteArrayInsertValueModification createCopy() { @Override protected byte[] modifyImplementationHook(byte[] input) { if (input == null) { - input = new byte[0]; + return null; } - // Wrap around and also allow to insert at the end of the original value int insertPosition = startPosition % (input.length + 1); if (startPosition < 0) { diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java index f76d25d3..9bffe16f 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayPrependValueModification.java @@ -42,9 +42,8 @@ public ByteArrayPrependValueModification createCopy() { @Override protected byte[] modifyImplementationHook(byte[] input) { if (input == null) { - input = new byte[0]; + return null; } - return ArrayConverter.concatenate(bytesToPrepend, input); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java index ff63f644..89e96ca9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayXorModification.java @@ -46,7 +46,7 @@ public ByteArrayXorModification createCopy() { @Override protected byte[] modifyImplementationHook(byte[] input) { if (input == null) { - input = new byte[0]; + return null; } if (input.length == 0) { return input; diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java index f148a113..54eabdcf 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerAddModification.java @@ -37,6 +37,9 @@ public IntegerAddModification createCopy() { @Override protected Integer modifyImplementationHook(Integer input) { + if (input == null) { + return null; + } return input + summand; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java index f98a06b8..052706f7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerExplicitValueModification.java @@ -38,7 +38,7 @@ public IntegerExplicitValueModification createCopy() { @Override protected Integer modifyImplementationHook(Integer input) { if (input == null) { - throw new NullPointerException("original value must not be null"); + return null; } return explicitValue; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java index a3c1c72d..9f3ab855 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModification.java @@ -37,6 +37,9 @@ public IntegerMultiplyModification createCopy() { @Override protected Integer modifyImplementationHook(Integer input) { + if (input == null) { + return null; + } return input * factor; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java index cd151156..98f6c922 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftLeftModification.java @@ -38,6 +38,9 @@ public IntegerShiftLeftModification createCopy() { @Override protected Integer modifyImplementationHook(Integer input) { + if (input == null) { + return null; + } return input << shift % MAX_SHIFT_MODIFIER; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java index 83e098f1..7b5a9379 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerShiftRightModification.java @@ -38,6 +38,9 @@ public IntegerShiftRightModification createCopy() { @Override protected Integer modifyImplementationHook(Integer input) { + if (input == null) { + return null; + } return input >> shift % MAX_SHIFT_MODIFIER; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java index 67958e8c..26347252 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSubtractModification.java @@ -37,6 +37,9 @@ public IntegerSubtractModification createCopy() { @Override protected Integer modifyImplementationHook(Integer input) { + if (input == null) { + return null; + } return input - subtrahend; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java index 91fde71c..4a7fcdf7 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModification.java @@ -28,6 +28,9 @@ public IntegerSwapEndianModification createCopy() { @Override protected Integer modifyImplementationHook(Integer input) { + if (input == null) { + return null; + } return Integer.reverseBytes(input); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java index 30602bd4..a557cb6a 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/integer/IntegerXorModification.java @@ -37,6 +37,9 @@ public IntegerXorModification createCopy() { @Override protected Integer modifyImplementationHook(Integer input) { + if (input == null) { + return null; + } return input ^ xor; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java index a09325d1..dfc74ff9 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongAddModification.java @@ -37,6 +37,9 @@ public LongAddModification createCopy() { @Override protected Long modifyImplementationHook(Long input) { + if (input == null) { + return null; + } return input + summand; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java index 2034142f..16c86c65 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongExplicitValueModification.java @@ -38,7 +38,7 @@ public LongExplicitValueModification createCopy() { @Override protected Long modifyImplementationHook(Long input) { if (input == null) { - throw new NullPointerException("original value must not be null"); + return null; } return explicitValue; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java index 33a890c1..ff602bc3 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongMultiplyModification.java @@ -37,7 +37,10 @@ public LongMultiplyModification createCopy() { @Override protected Long modifyImplementationHook(Long input) { - return input == null ? 0L : input * factor; + if (input == null) { + return null; + } + return input * factor; } public Long getFactor() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java index 359ccf16..2b783bea 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftLeftModification.java @@ -39,7 +39,10 @@ public LongShiftLeftModification createCopy() { @Override protected Long modifyImplementationHook(Long input) { - return input == null ? 0L : input << shift % MAX_SHIFT_MODIFIER; + if (input == null) { + return null; + } + return input << shift % MAX_SHIFT_MODIFIER; } public int getShift() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java index 145d3fb2..9374ec48 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongShiftRightModification.java @@ -39,7 +39,10 @@ public LongShiftRightModification createCopy() { @Override protected Long modifyImplementationHook(Long input) { - return input == null ? 0L : input >> shift % MAX_SHIFT_MODIFIER; + if (input == null) { + return null; + } + return input >> shift % MAX_SHIFT_MODIFIER; } public int getShift() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java index 3493a510..20f0265b 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongSubtractModification.java @@ -37,7 +37,10 @@ public LongSubtractModification createCopy() { @Override protected Long modifyImplementationHook(Long input) { - return input == null ? -subtrahend : input - subtrahend; + if (input == null) { + return null; + } + return input - subtrahend; } public Long getSubtrahend() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java index 9fbe85d5..b21ae19e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/longint/LongXorModification.java @@ -37,7 +37,10 @@ public LongXorModification createCopy() { @Override protected Long modifyImplementationHook(Long input) { - return input == null ? xor : input ^ xor; + if (input == null) { + return null; + } + return input ^ xor; } public Long getXor() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java index 0c2153e1..d24dda63 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteAddModification.java @@ -38,7 +38,7 @@ public ByteAddModification createCopy() { @Override protected Byte modifyImplementationHook(Byte input) { if (input == null) { - input = 0; + return null; } return (byte) (input + summand); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java index c7ad1284..8ad69330 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteExplicitValueModification.java @@ -38,7 +38,7 @@ public ByteExplicitValueModification createCopy() { @Override protected Byte modifyImplementationHook(Byte input) { if (input == null) { - throw new NullPointerException("original value must not be null"); + return null; } return explicitValue; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java index 672a7c1d..c422e60c 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteSubtractModification.java @@ -38,7 +38,7 @@ public ByteSubtractModification createCopy() { @Override protected Byte modifyImplementationHook(Byte input) { if (input == null) { - input = 0; + return null; } return (byte) (input - subtrahend); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java index 2954e0bf..9b0ffc6e 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/singlebyte/ByteXorModification.java @@ -38,7 +38,7 @@ public ByteXorModification createCopy() { @Override protected Byte modifyImplementationHook(Byte input) { if (input == null) { - input = 0; + return null; } return (byte) (input ^ xor); } diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java index 22f6ebee..5a494254 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringAppendValueModification.java @@ -43,7 +43,10 @@ public StringAppendValueModification createCopy() { @Override protected String modifyImplementationHook(String input) { - return input != null ? input + appendValue : appendValue; + if (input == null) { + return null; + } + return input + appendValue; } public String getAppendValue() { diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java index 764efc78..e5dc57bd 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringExplicitValueModification.java @@ -43,7 +43,7 @@ public StringExplicitValueModification createCopy() { @Override protected String modifyImplementationHook(String input) { if (input == null) { - throw new NullPointerException("original value must not be null"); + return null; } return explicitValue; } diff --git a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java index 47441905..c0176754 100644 --- a/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java +++ b/src/main/java/de/rub/nds/modifiablevariable/string/StringPrependValueModification.java @@ -43,7 +43,10 @@ public StringPrependValueModification createCopy() { @Override protected String modifyImplementationHook(String input) { - return input != null ? prependValue + input : prependValue; + if (input == null) { + return null; + } + return prependValue + input; } public String getPrependValue() { diff --git a/src/test/java/de/rub/nds/modifiablevariable/HoldsModifiableVariableTest.java b/src/test/java/de/rub/nds/modifiablevariable/HoldsModifiableVariableTest.java index 935a460c..2eabf1e3 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/HoldsModifiableVariableTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/HoldsModifiableVariableTest.java @@ -30,7 +30,7 @@ private static class TestClass { } @Test - public void testAnnotationPresence() throws NoSuchFieldException { + void testAnnotationPresence() throws NoSuchFieldException { Field holderField = TestClass.class.getDeclaredField("holder"); HoldsModifiableVariable annotation = holderField.getAnnotation(HoldsModifiableVariable.class); @@ -39,7 +39,7 @@ public void testAnnotationPresence() throws NoSuchFieldException { } @Test - public void testListFieldAnnotation() throws NoSuchFieldException { + void testListFieldAnnotation() throws NoSuchFieldException { Field listField = TestClass.class.getDeclaredField("integerList"); HoldsModifiableVariable annotation = listField.getAnnotation(HoldsModifiableVariable.class); @@ -47,7 +47,7 @@ public void testListFieldAnnotation() throws NoSuchFieldException { } @Test - public void testNoAnnotation() throws NoSuchFieldException { + void testNoAnnotation() throws NoSuchFieldException { Field regularField = TestClass.class.getDeclaredField("regularHolder"); HoldsModifiableVariable annotation = regularField.getAnnotation(HoldsModifiableVariable.class); @@ -56,7 +56,7 @@ public void testNoAnnotation() throws NoSuchFieldException { } @Test - public void testFindAnnotatedFields() { + void testFindAnnotatedFields() { // Use ReflectionHelper to find fields with the annotation List fields = ReflectionHelper.getFieldsUpTo(TestClass.class, Object.class, null); diff --git a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModificationTest.java index d7b19d83..680c690a 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModificationTest.java @@ -34,7 +34,7 @@ public void setUp() { public void testModifyImplementationHook() { assertEquals(BigInteger.valueOf(11), b1.modifyImplementationHook(BigInteger.TEN)); assertEquals(BigInteger.valueOf(2), b3.modifyImplementationHook(BigInteger.ONE)); - assertEquals(BigInteger.ONE, b1.modifyImplementationHook(null)); + assertEquals(null, b1.modifyImplementationHook(null)); } /** Test of getSummand method, of class BigIntegerAddModification. */ diff --git a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModificationTest.java index 86f3a162..265e2c43 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModificationTest.java @@ -85,7 +85,7 @@ public void testShiftLeftWithNullInput() { BigIntegerShiftLeftModification modification = new BigIntegerShiftLeftModification(shift); modifiableBigInteger.setModifications(modification); - BigInteger expected = BigInteger.ZERO.shiftLeft(shift); // Should treat null as ZERO + BigInteger expected = null; BigInteger result = modifiableBigInteger.getValue(); assertEquals(expected, result); diff --git a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModificationTest.java index 72c384bd..24dc271a 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModificationTest.java @@ -89,7 +89,7 @@ public void testShiftRightWithNullInput() { BigIntegerShiftRightModification modification = new BigIntegerShiftRightModification(shift); modifiableBigInteger.setModifications(modification); - BigInteger expected = BigInteger.ZERO.shiftRight(shift); // Should treat null as ZERO + BigInteger expected = null; BigInteger result = modifiableBigInteger.getValue(); assertEquals(expected, result); diff --git a/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerModificationTest.java index 81560416..a7fa292e 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerModificationTest.java @@ -8,6 +8,7 @@ package de.rub.nds.modifiablevariable.integer; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; import de.rub.nds.modifiablevariable.VariableModification; import org.junit.jupiter.api.BeforeEach; @@ -53,11 +54,7 @@ void testAddWithNullInput() { VariableModification modifier = new IntegerAddModification(1); start.setOriginalValue(null); start.setModifications(modifier); - org.junit.jupiter.api.Assertions.assertThrows( - NullPointerException.class, - () -> { - start.getValue(); - }); + assertNull(start.getValue()); } /** Test of sub method, of class IntegerModification. */ @@ -77,11 +74,7 @@ void testSubWithNullInput() { VariableModification modifier = new IntegerSubtractModification(1); start.setOriginalValue(null); start.setModifications(modifier); - org.junit.jupiter.api.Assertions.assertThrows( - NullPointerException.class, - () -> { - start.getValue(); - }); + assertNull(start.getValue()); } /** Test of xor method, of class IntegerModification. */ @@ -101,11 +94,7 @@ void testXorWithNullInput() { VariableModification modifier = new IntegerXorModification(2); start.setOriginalValue(null); start.setModifications(modifier); - org.junit.jupiter.api.Assertions.assertThrows( - NullPointerException.class, - () -> { - start.getValue(); - }); + assertNull(start.getValue()); } /** Test of explicitValue method, of class IntegerModification. */ @@ -135,11 +124,7 @@ void testExplicitValueWithNullInput() { VariableModification modifier = new IntegerExplicitValueModification(7); start.setOriginalValue(null); start.setModifications(modifier); - org.junit.jupiter.api.Assertions.assertThrows( - NullPointerException.class, - () -> { - start.getValue(); - }); + assertNull(start.getValue()); } /** Test of shiftLeft method, of class IntegerModification. */ @@ -201,11 +186,7 @@ void testSwapEndianWithNullInput() { VariableModification modifier = new IntegerSwapEndianModification(); start.setOriginalValue(null); start.setModifications(modifier); - org.junit.jupiter.api.Assertions.assertThrows( - NullPointerException.class, - () -> { - start.getValue(); - }); + assertNull(start.getValue()); } /** Test of multiply method, of class IntegerModification. */ @@ -245,11 +226,7 @@ void testMultiplyWithNullInput() { VariableModification modifier = new IntegerMultiplyModification(2); start.setOriginalValue(null); start.setModifications(modifier); - org.junit.jupiter.api.Assertions.assertThrows( - NullPointerException.class, - () -> { - start.getValue(); - }); + assertNull(start.getValue()); } /** Test of multiple modifications, of class IntegerModification. */ diff --git a/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModificationTest.java index 315708d0..04ca17d5 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerMultiplyModificationTest.java @@ -10,6 +10,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -82,12 +83,7 @@ public void testMultiplyWithNullInput() { int factor = 5; IntegerMultiplyModification modification = new IntegerMultiplyModification(factor); modifiableInteger.setModifications(modification); - - org.junit.jupiter.api.Assertions.assertThrows( - NullPointerException.class, - () -> { - modifiableInteger.getValue(); - }); + assertNull(modifiableInteger.getValue()); } @Test diff --git a/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerShiftModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerShiftModificationTest.java index 2d22380d..1c08f584 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerShiftModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerShiftModificationTest.java @@ -9,6 +9,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNull; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -69,11 +70,7 @@ public void testShiftLeftWithNullInput() { IntegerShiftLeftModification modification = new IntegerShiftLeftModification(shift); modifiableInteger.setModifications(modification); - org.junit.jupiter.api.Assertions.assertThrows( - NullPointerException.class, - () -> { - modifiableInteger.getValue(); - }); + assertNull(modifiableInteger.getValue()); } @Test @@ -160,12 +157,7 @@ public void testShiftRightWithNullInput() { int shift = 4; IntegerShiftRightModification modification = new IntegerShiftRightModification(shift); modifiableInteger.setModifications(modification); - - org.junit.jupiter.api.Assertions.assertThrows( - NullPointerException.class, - () -> { - modifiableInteger.getValue(); - }); + assertNull(modifiableInteger.getValue()); } @Test diff --git a/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModificationTest.java index eca5d8b7..9d9b1176 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/integer/IntegerSwapEndianModificationTest.java @@ -10,6 +10,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -57,11 +58,7 @@ void testSwapEndianWithNullInput() { IntegerSwapEndianModification modification = new IntegerSwapEndianModification(); modifiableInteger.setModifications(modification); - org.junit.jupiter.api.Assertions.assertThrows( - NullPointerException.class, - () -> { - modifiableInteger.getValue(); - }); + assertNull(modifiableInteger.getValue()); } @Test diff --git a/src/test/java/de/rub/nds/modifiablevariable/integer/ModifiableIntegerTest.java b/src/test/java/de/rub/nds/modifiablevariable/integer/ModifiableIntegerTest.java index 96207280..aaf91c6a 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/integer/ModifiableIntegerTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/integer/ModifiableIntegerTest.java @@ -158,11 +158,7 @@ void testIsOriginalValueModified() { () -> { nullIntWithExplicit.isOriginalValueModified(); }); - org.junit.jupiter.api.Assertions.assertThrows( - NullPointerException.class, - () -> { - nullIntWithExplicit.getValue(); - }); + assertNull(nullIntWithExplicit.getValue()); } /** Test of getOriginalValue method, of class ModifiableInteger. */ diff --git a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongAddModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongAddModificationTest.java new file mode 100644 index 00000000..1b02c966 --- /dev/null +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongAddModificationTest.java @@ -0,0 +1,94 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.mlong; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; + +import de.rub.nds.modifiablevariable.longint.LongAddModification; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class LongAddModificationTest { + + private LongAddModification modification; + private final Long summand = 5L; + + @BeforeEach + public void setUp() { + modification = new LongAddModification(summand); + } + + @Test + public void testCreateCopy() { + LongAddModification copy = modification.createCopy(); + assertNotNull(copy); + assertEquals(modification, copy); + assertEquals(modification.getSummand(), copy.getSummand()); + assertNotSame(modification, copy); + } + + @Test + public void testEquals() { + LongAddModification equalModification = new LongAddModification(summand); + LongAddModification differentModification = new LongAddModification(10L); + + // Test reflexivity + assertEquals(modification, modification); + + // Test symmetry + assertEquals(modification, equalModification); + assertEquals(equalModification, modification); + + // Test with different values + assertNotEquals(modification, differentModification); + + // Test with null and different object type + assertNotEquals(modification, null); + assertNotEquals(modification, "string"); + } + + @Test + public void testHashCode() { + LongAddModification equalModification = new LongAddModification(summand); + + // Equal objects should have equal hash codes + assertEquals(modification.hashCode(), equalModification.hashCode()); + } + + @Test + public void testGetSummand() { + assertEquals(summand, modification.getSummand()); + } + + @Test + public void testSetSummand() { + Long newSummand = 20L; + modification.setSummand(newSummand); + assertEquals(newSummand, modification.getSummand()); + } + + @Test + public void testToString() { + String expected = "LongAddModification{summand=5}"; + assertEquals(expected, modification.toString()); + } + + @Test + public void testConstructors() { + // Test default constructor + LongAddModification defaultConstructor = new LongAddModification(); + assertNotNull(defaultConstructor); + + // Test copy constructor + LongAddModification copy = new LongAddModification(modification); + assertEquals(modification.getSummand(), copy.getSummand()); + } +} diff --git a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongExplicitValueModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongExplicitValueModificationTest.java new file mode 100644 index 00000000..379faa34 --- /dev/null +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongExplicitValueModificationTest.java @@ -0,0 +1,97 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.mlong; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; + +import de.rub.nds.modifiablevariable.longint.LongExplicitValueModification; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class LongExplicitValueModificationTest { + + private LongExplicitValueModification modification; + private final Long explicitValue = 42L; + + @BeforeEach + public void setUp() { + modification = new LongExplicitValueModification(explicitValue); + } + + @Test + public void testCreateCopy() { + LongExplicitValueModification copy = modification.createCopy(); + assertNotNull(copy); + assertEquals(modification, copy); + assertEquals(modification.getExplicitValue(), copy.getExplicitValue()); + assertNotSame(modification, copy); + } + + @Test + public void testEquals() { + LongExplicitValueModification equalModification = + new LongExplicitValueModification(explicitValue); + LongExplicitValueModification differentModification = + new LongExplicitValueModification(10L); + + // Test reflexivity + assertEquals(modification, modification); + + // Test symmetry + assertEquals(modification, equalModification); + assertEquals(equalModification, modification); + + // Test with different values + assertNotEquals(modification, differentModification); + + // Test with null and different object type + assertNotEquals(modification, null); + assertNotEquals(modification, "string"); + } + + @Test + public void testHashCode() { + LongExplicitValueModification equalModification = + new LongExplicitValueModification(explicitValue); + + // Equal objects should have equal hash codes + assertEquals(modification.hashCode(), equalModification.hashCode()); + } + + @Test + public void testGetExplicitValue() { + assertEquals(explicitValue, modification.getExplicitValue()); + } + + @Test + public void testSetExplicitValue() { + Long newValue = 20L; + modification.setExplicitValue(newValue); + assertEquals(newValue, modification.getExplicitValue()); + } + + @Test + public void testToString() { + String expected = "LongExplicitValueModification{explicitValue=42}"; + assertEquals(expected, modification.toString()); + } + + @Test + public void testConstructors() { + // Test default constructor + LongExplicitValueModification defaultConstructor = new LongExplicitValueModification(); + assertNotNull(defaultConstructor); + + // Test copy constructor + LongExplicitValueModification copy = new LongExplicitValueModification(modification); + assertEquals(modification.getExplicitValue(), copy.getExplicitValue()); + } +} diff --git a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationFactoryTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationFactoryTest.java new file mode 100644 index 00000000..c1764c74 --- /dev/null +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationFactoryTest.java @@ -0,0 +1,105 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.mlong; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import de.rub.nds.modifiablevariable.VariableModification; +import de.rub.nds.modifiablevariable.longint.LongAddModification; +import de.rub.nds.modifiablevariable.longint.LongExplicitValueModification; +import de.rub.nds.modifiablevariable.longint.LongMultiplyModification; +import de.rub.nds.modifiablevariable.longint.LongShiftLeftModification; +import de.rub.nds.modifiablevariable.longint.LongShiftRightModification; +import de.rub.nds.modifiablevariable.longint.LongSubtractModification; +import de.rub.nds.modifiablevariable.longint.LongSwapEndianModification; +import de.rub.nds.modifiablevariable.longint.LongXorModification; +import org.junit.jupiter.api.Test; + +public class LongModificationFactoryTest { + + @Test + public void testAddWithLong() { + Long summand = 10L; + VariableModification modification = new LongAddModification(summand); + + assertNotNull(modification); + assertTrue(modification instanceof LongAddModification); + assertEquals(summand, ((LongAddModification) modification).getSummand()); + } + + @Test + public void testSubWithLong() { + Long subtrahend = 10L; + VariableModification modification = new LongSubtractModification(subtrahend); + + assertNotNull(modification); + assertTrue(modification instanceof LongSubtractModification); + assertEquals(subtrahend, ((LongSubtractModification) modification).getSubtrahend()); + } + + @Test + public void testXorWithLong() { + Long xorValue = 10L; + VariableModification modification = new LongXorModification(xorValue); + + assertNotNull(modification); + assertTrue(modification instanceof LongXorModification); + assertEquals(xorValue, ((LongXorModification) modification).getXor()); + } + + @Test + public void testSwapEndian() { + VariableModification modification = new LongSwapEndianModification(); + + assertNotNull(modification); + assertTrue(modification instanceof LongSwapEndianModification); + } + + @Test + public void testExplicitValueWithLong() { + Long explicitValue = 10L; + VariableModification modification = new LongExplicitValueModification(explicitValue); + + assertNotNull(modification); + assertTrue(modification instanceof LongExplicitValueModification); + assertEquals( + explicitValue, ((LongExplicitValueModification) modification).getExplicitValue()); + } + + @Test + public void testMultiply() { + Long factor = 10L; + VariableModification modification = new LongMultiplyModification(factor); + + assertNotNull(modification); + assertTrue(modification instanceof LongMultiplyModification); + assertEquals(factor, ((LongMultiplyModification) modification).getFactor()); + } + + @Test + public void testShiftLeft() { + int shift = 5; + VariableModification modification = new LongShiftLeftModification(shift); + + assertNotNull(modification); + assertTrue(modification instanceof LongShiftLeftModification); + assertEquals(shift, ((LongShiftLeftModification) modification).getShift()); + } + + @Test + public void testShiftRight() { + int shift = 5; + VariableModification modification = new LongShiftRightModification(shift); + + assertNotNull(modification); + assertTrue(modification instanceof LongShiftRightModification); + assertEquals(shift, ((LongShiftRightModification) modification).getShift()); + } +} diff --git a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java index 3d883ac7..4481d993 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationTest.java @@ -8,11 +8,16 @@ package de.rub.nds.modifiablevariable.mlong; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; import de.rub.nds.modifiablevariable.VariableModification; import de.rub.nds.modifiablevariable.longint.LongAddModification; import de.rub.nds.modifiablevariable.longint.LongExplicitValueModification; +import de.rub.nds.modifiablevariable.longint.LongMultiplyModification; +import de.rub.nds.modifiablevariable.longint.LongShiftLeftModification; +import de.rub.nds.modifiablevariable.longint.LongShiftRightModification; import de.rub.nds.modifiablevariable.longint.LongSubtractModification; +import de.rub.nds.modifiablevariable.longint.LongSwapEndianModification; import de.rub.nds.modifiablevariable.longint.LongXorModification; import de.rub.nds.modifiablevariable.longint.ModifiableLong; import org.junit.jupiter.api.BeforeEach; @@ -26,7 +31,6 @@ public class LongModificationTest { @BeforeEach public void setUp() { - start = new ModifiableLong(); start.setOriginalValue(10L); expectedResult = null; @@ -41,7 +45,7 @@ public void testAdd() { expectedResult = 11L; result = start.getValue(); assertEquals(expectedResult, result); - assertEquals(Long.valueOf(10L), start.getOriginalValue()); + assertEquals(10L, start.getOriginalValue()); } @Test @@ -51,7 +55,7 @@ public void testSub() { expectedResult = 9L; result = start.getValue(); assertEquals(expectedResult, result); - assertEquals(Long.valueOf(10L), start.getOriginalValue()); + assertEquals(10L, start.getOriginalValue()); } @Test @@ -61,7 +65,7 @@ public void testXor() { expectedResult = 8L; result = start.getValue(); assertEquals(expectedResult, result); - assertEquals(Long.valueOf(10L), start.getOriginalValue()); + assertEquals(10L, start.getOriginalValue()); } @Test @@ -71,6 +75,145 @@ public void testExplicitValue() { expectedResult = 7L; result = start.getValue(); assertEquals(expectedResult, result); - assertEquals(Long.valueOf(10L), start.getOriginalValue()); + assertEquals(10L, start.getOriginalValue()); + } + + @Test + public void testMultiply() { + VariableModification modifier = new LongMultiplyModification(3L); + start.setModifications(modifier); + expectedResult = 30L; + result = start.getValue(); + assertEquals(expectedResult, result); + assertEquals(10L, start.getOriginalValue()); + } + + @Test + public void testMultiplyWithZero() { + VariableModification modifier = new LongMultiplyModification(0L); + start.setModifications(modifier); + expectedResult = 0L; + result = start.getValue(); + assertEquals(expectedResult, result); + assertEquals(10L, start.getOriginalValue()); + } + + @Test + public void testMultiplyWithNull() { + ModifiableLong nullStart = new ModifiableLong(); + VariableModification modifier = new LongMultiplyModification(5L); + nullStart.setModifications(modifier); + assertNull(nullStart.getValue()); + } + + @Test + public void testShiftLeft() { + VariableModification modifier = new LongShiftLeftModification(2); + start.setModifications(modifier); + expectedResult = 40L; // 10 << 2 = 40 + result = start.getValue(); + assertEquals(expectedResult, result); + assertEquals(10L, start.getOriginalValue()); + } + + @Test + public void testShiftLeftWithLargeShift() { + VariableModification modifier = new LongShiftLeftModification(65); + start.setModifications(modifier); + expectedResult = 20L; // (10 << 65) % 64 = (10 << 1) = 20 + result = start.getValue(); + assertEquals(expectedResult, result); + assertEquals(10L, start.getOriginalValue()); + } + + @Test + public void testShiftLeftWithNull() { + ModifiableLong nullStart = new ModifiableLong(); + VariableModification modifier = new LongShiftLeftModification(2); + nullStart.setModifications(modifier); + assertNull(nullStart.getValue()); + } + + @Test + public void testShiftRight() { + start.setOriginalValue(40L); + VariableModification modifier = new LongShiftRightModification(2); + start.setModifications(modifier); + expectedResult = 10L; // 40 >> 2 = 10 + result = start.getValue(); + assertEquals(expectedResult, result); + assertEquals(40L, start.getOriginalValue()); + } + + @Test + public void testShiftRightWithLargeShift() { + start.setOriginalValue(40L); + VariableModification modifier = new LongShiftRightModification(66); + start.setModifications(modifier); + expectedResult = 10L; // (40 >> 66) % 64 = (40 >> 2) = 10 + result = start.getValue(); + assertEquals(expectedResult, result); + assertEquals(40L, start.getOriginalValue()); + } + + @Test + public void testShiftRightWithNull() { + ModifiableLong nullStart = new ModifiableLong(); + VariableModification modifier = new LongShiftRightModification(2); + nullStart.setModifications(modifier); + expectedResult = null; + result = nullStart.getValue(); + assertEquals(expectedResult, result); + } + + @Test + public void testSwapEndian() { + start.setOriginalValue(0x1122334455667788L); + VariableModification modifier = new LongSwapEndianModification(); + start.setModifications(modifier); + expectedResult = 0x8877665544332211L; // Byte-swapped value + result = start.getValue(); + assertEquals(expectedResult, result); + assertEquals(Long.valueOf(0x1122334455667788L), start.getOriginalValue()); + } + + @Test + public void testSwapEndianWithNull() { + ModifiableLong nullStart = new ModifiableLong(); + VariableModification modifier = new LongSwapEndianModification(); + nullStart.setModifications(modifier); + assertNull(nullStart.getValue()); + } + + @Test + public void testMultipleModifications() { + // Test add followed by multiply + VariableModification addModifier = new LongAddModification(5L); + VariableModification multiplyModifier = new LongMultiplyModification(2L); + start.setModifications(addModifier); + start.addModification(multiplyModifier); + expectedResult = 30L; // (10 + 5) * 2 = 30 + result = start.getValue(); + assertEquals(expectedResult, result); + assertEquals(10L, start.getOriginalValue()); + } + + @Test + public void testBoundaryValues() { + // Test with Long.MAX_VALUE + start.setOriginalValue(Long.MAX_VALUE); + VariableModification addModifier = new LongAddModification(1L); + start.setModifications(addModifier); + expectedResult = Long.MIN_VALUE; // Overflow wraps around + result = start.getValue(); + assertEquals(expectedResult, result); + + // Test with Long.MIN_VALUE + start.setOriginalValue(Long.MIN_VALUE); + VariableModification subModifier = new LongSubtractModification(1L); + start.setModifications(subModifier); + expectedResult = Long.MAX_VALUE; // Underflow wraps around + result = start.getValue(); + assertEquals(expectedResult, result); } } diff --git a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongMultiplyModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongMultiplyModificationTest.java new file mode 100644 index 00000000..9283deab --- /dev/null +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongMultiplyModificationTest.java @@ -0,0 +1,94 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.mlong; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; + +import de.rub.nds.modifiablevariable.longint.LongMultiplyModification; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class LongMultiplyModificationTest { + + private LongMultiplyModification modification; + private final Long factor = 5L; + + @BeforeEach + public void setUp() { + modification = new LongMultiplyModification(factor); + } + + @Test + public void testCreateCopy() { + LongMultiplyModification copy = modification.createCopy(); + assertNotNull(copy); + assertEquals(modification, copy); + assertEquals(modification.getFactor(), copy.getFactor()); + assertNotSame(modification, copy); + } + + @Test + public void testEquals() { + LongMultiplyModification equalModification = new LongMultiplyModification(factor); + LongMultiplyModification differentModification = new LongMultiplyModification(10L); + + // Test reflexivity + assertEquals(modification, modification); + + // Test symmetry + assertEquals(modification, equalModification); + assertEquals(equalModification, modification); + + // Test with different values + assertNotEquals(modification, differentModification); + + // Test with null and different object type + assertNotEquals(modification, null); + assertNotEquals(modification, "string"); + } + + @Test + public void testHashCode() { + LongMultiplyModification equalModification = new LongMultiplyModification(factor); + + // Equal objects should have equal hash codes + assertEquals(modification.hashCode(), equalModification.hashCode()); + } + + @Test + public void testGetFactor() { + assertEquals(factor, modification.getFactor()); + } + + @Test + public void testSetFactor() { + Long newFactor = 20L; + modification.setFactor(newFactor); + assertEquals(newFactor, modification.getFactor()); + } + + @Test + public void testToString() { + String expected = "LongMultiplyModification{factor=5}"; + assertEquals(expected, modification.toString()); + } + + @Test + public void testConstructors() { + // Test default constructor + LongMultiplyModification defaultConstructor = new LongMultiplyModification(); + assertNotNull(defaultConstructor); + + // Test copy constructor + LongMultiplyModification copy = new LongMultiplyModification(modification); + assertEquals(modification.getFactor(), copy.getFactor()); + } +} diff --git a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongShiftLeftModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongShiftLeftModificationTest.java new file mode 100644 index 00000000..1f643f1e --- /dev/null +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongShiftLeftModificationTest.java @@ -0,0 +1,92 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.mlong; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import de.rub.nds.modifiablevariable.longint.LongShiftLeftModification; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class LongShiftLeftModificationTest { + + private LongShiftLeftModification modification; + private final int shift = 3; + + @BeforeEach + public void setUp() { + modification = new LongShiftLeftModification(shift); + } + + @Test + public void testCreateCopy() { + LongShiftLeftModification copy = modification.createCopy(); + assertNotNull(copy); + assertEquals(modification, copy); + assertEquals(modification.getShift(), copy.getShift()); + } + + @Test + public void testEquals() { + LongShiftLeftModification equalModification = new LongShiftLeftModification(shift); + LongShiftLeftModification differentModification = new LongShiftLeftModification(10); + + // Test reflexivity + assertEquals(modification, modification); + + // Test symmetry + assertEquals(modification, equalModification); + assertEquals(equalModification, modification); + + // Test with different values + assertNotEquals(modification, differentModification); + + // Test with null and different object type + assertNotEquals(modification, null); + assertNotEquals(modification, "string"); + } + + @Test + public void testHashCode() { + LongShiftLeftModification equalModification = new LongShiftLeftModification(shift); + + // Equal objects should have equal hash codes + assertEquals(modification.hashCode(), equalModification.hashCode()); + } + + @Test + public void testGetShift() { + assertEquals(shift, modification.getShift()); + } + + @Test + public void testSetShift() { + int newShift = 20; + modification.setShift(newShift); + assertEquals(newShift, modification.getShift()); + } + + @Test + public void testToString() { + String expected = "LongShiftLeftModification{shift=3}"; + assertEquals(expected, modification.toString()); + } + + @Test + public void testConstructors() { + // Test default constructor + LongShiftLeftModification defaultConstructor = new LongShiftLeftModification(); + assertNotNull(defaultConstructor); + + // Test copy constructor + LongShiftLeftModification copy = new LongShiftLeftModification(modification); + assertEquals(modification.getShift(), copy.getShift()); + } +} diff --git a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongShiftRightModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongShiftRightModificationTest.java new file mode 100644 index 00000000..04fd1ebe --- /dev/null +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongShiftRightModificationTest.java @@ -0,0 +1,94 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.mlong; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; + +import de.rub.nds.modifiablevariable.longint.LongShiftRightModification; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class LongShiftRightModificationTest { + + private LongShiftRightModification modification; + private final int shift = 3; + + @BeforeEach + public void setUp() { + modification = new LongShiftRightModification(shift); + } + + @Test + public void testCreateCopy() { + LongShiftRightModification copy = modification.createCopy(); + assertNotNull(copy); + assertEquals(modification, copy); + assertEquals(modification.getShift(), copy.getShift()); + assertNotSame(modification, copy); + } + + @Test + public void testEquals() { + LongShiftRightModification equalModification = new LongShiftRightModification(shift); + LongShiftRightModification differentModification = new LongShiftRightModification(10); + + // Test reflexivity + assertEquals(modification, modification); + + // Test symmetry + assertEquals(modification, equalModification); + assertEquals(equalModification, modification); + + // Test with different values + assertNotEquals(modification, differentModification); + + // Test with null and different object type + assertNotEquals(modification, null); + assertNotEquals(modification, "string"); + } + + @Test + public void testHashCode() { + LongShiftRightModification equalModification = new LongShiftRightModification(shift); + + // Equal objects should have equal hash codes + assertEquals(modification.hashCode(), equalModification.hashCode()); + } + + @Test + public void testGetShift() { + assertEquals(shift, modification.getShift()); + } + + @Test + public void testSetShift() { + int newShift = 20; + modification.setShift(newShift); + assertEquals(newShift, modification.getShift()); + } + + @Test + public void testToString() { + String expected = "LongShiftRightModification{shift=3}"; + assertEquals(expected, modification.toString()); + } + + @Test + public void testConstructors() { + // Test default constructor + LongShiftRightModification defaultConstructor = new LongShiftRightModification(); + assertNotNull(defaultConstructor); + + // Test copy constructor + LongShiftRightModification copy = new LongShiftRightModification(modification); + assertEquals(modification.getShift(), copy.getShift()); + } +} diff --git a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongSubtractModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongSubtractModificationTest.java new file mode 100644 index 00000000..83254a03 --- /dev/null +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongSubtractModificationTest.java @@ -0,0 +1,92 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.mlong; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import de.rub.nds.modifiablevariable.longint.LongSubtractModification; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class LongSubtractModificationTest { + + private LongSubtractModification modification; + private final Long subtrahend = 5L; + + @BeforeEach + public void setUp() { + modification = new LongSubtractModification(subtrahend); + } + + @Test + public void testCreateCopy() { + LongSubtractModification copy = modification.createCopy(); + assertNotNull(copy); + assertEquals(modification, copy); + assertEquals(modification.getSubtrahend(), copy.getSubtrahend()); + } + + @Test + public void testEquals() { + LongSubtractModification equalModification = new LongSubtractModification(subtrahend); + LongSubtractModification differentModification = new LongSubtractModification(10L); + + // Test reflexivity + assertEquals(modification, modification); + + // Test symmetry + assertEquals(modification, equalModification); + assertEquals(equalModification, modification); + + // Test with different values + assertNotEquals(modification, differentModification); + + // Test with null and different object type + assertNotEquals(modification, null); + assertNotEquals(modification, "string"); + } + + @Test + public void testHashCode() { + LongSubtractModification equalModification = new LongSubtractModification(subtrahend); + + // Equal objects should have equal hash codes + assertEquals(modification.hashCode(), equalModification.hashCode()); + } + + @Test + public void testGetSubtrahend() { + assertEquals(subtrahend, modification.getSubtrahend()); + } + + @Test + public void testSetSubtrahend() { + Long newSubtrahend = 20L; + modification.setSubtrahend(newSubtrahend); + assertEquals(newSubtrahend, modification.getSubtrahend()); + } + + @Test + public void testToString() { + String expected = "LongSubtractModification{subtrahend=5}"; + assertEquals(expected, modification.toString()); + } + + @Test + public void testConstructors() { + // Test default constructor + LongSubtractModification defaultConstructor = new LongSubtractModification(); + assertNotNull(defaultConstructor); + + // Test copy constructor + LongSubtractModification copy = new LongSubtractModification(modification); + assertEquals(modification.getSubtrahend(), copy.getSubtrahend()); + } +} diff --git a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongSwapEndianModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongSwapEndianModificationTest.java new file mode 100644 index 00000000..fce0e43b --- /dev/null +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongSwapEndianModificationTest.java @@ -0,0 +1,76 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.mlong; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; + +import de.rub.nds.modifiablevariable.longint.LongSwapEndianModification; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class LongSwapEndianModificationTest { + + private LongSwapEndianModification modification; + + @BeforeEach + public void setUp() { + modification = new LongSwapEndianModification(); + } + + @Test + public void testCreateCopy() { + LongSwapEndianModification copy = modification.createCopy(); + assertNotNull(copy); + assertEquals(modification, copy); + assertNotSame(modification, copy); + } + + @Test + public void testEquals() { + LongSwapEndianModification equalModification = new LongSwapEndianModification(); + + // Test reflexivity + assertEquals(modification, modification); + + // Test symmetry + assertEquals(modification, equalModification); + assertEquals(equalModification, modification); + + // Test with null and different object type + assertNotEquals(modification, null); + assertNotEquals(modification, "string"); + } + + @Test + public void testHashCode() { + LongSwapEndianModification equalModification = new LongSwapEndianModification(); + + // Equal objects should have equal hash codes + assertEquals(modification.hashCode(), equalModification.hashCode()); + } + + @Test + public void testToString() { + String expected = "LongSwapEndianModification{}"; + assertEquals(expected, modification.toString()); + } + + @Test + public void testConstructors() { + // Test default constructor + LongSwapEndianModification defaultConstructor = new LongSwapEndianModification(); + assertNotNull(defaultConstructor); + + // Test copy constructor + LongSwapEndianModification copy = new LongSwapEndianModification(modification); + assertEquals(modification, copy); + } +} diff --git a/src/test/java/de/rub/nds/modifiablevariable/mlong/LongXorModificationTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongXorModificationTest.java new file mode 100644 index 00000000..3a010bb4 --- /dev/null +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/LongXorModificationTest.java @@ -0,0 +1,94 @@ +/* + * ModifiableVariable - A Variable Concept for Runtime Modifications + * + * Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 + */ +package de.rub.nds.modifiablevariable.mlong; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; + +import de.rub.nds.modifiablevariable.longint.LongXorModification; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class LongXorModificationTest { + + private LongXorModification modification; + private final Long xor = 5L; + + @BeforeEach + public void setUp() { + modification = new LongXorModification(xor); + } + + @Test + public void testCreateCopy() { + LongXorModification copy = modification.createCopy(); + assertNotNull(copy); + assertEquals(modification, copy); + assertEquals(modification.getXor(), copy.getXor()); + assertNotSame(modification, copy); + } + + @Test + public void testEquals() { + LongXorModification equalModification = new LongXorModification(xor); + LongXorModification differentModification = new LongXorModification(10L); + + // Test reflexivity + assertEquals(modification, modification); + + // Test symmetry + assertEquals(modification, equalModification); + assertEquals(equalModification, modification); + + // Test with different values + assertNotEquals(modification, differentModification); + + // Test with null and different object type + assertNotEquals(modification, null); + assertNotEquals(modification, "string"); + } + + @Test + public void testHashCode() { + LongXorModification equalModification = new LongXorModification(xor); + + // Equal objects should have equal hash codes + assertEquals(modification.hashCode(), equalModification.hashCode()); + } + + @Test + public void testGetXor() { + assertEquals(xor, modification.getXor()); + } + + @Test + public void testSetXor() { + Long newXor = 20L; + modification.setXor(newXor); + assertEquals(newXor, modification.getXor()); + } + + @Test + public void testToString() { + String expected = "LongXorModification{xor=5}"; + assertEquals(expected, modification.toString()); + } + + @Test + public void testConstructors() { + // Test default constructor + LongXorModification defaultConstructor = new LongXorModification(); + assertNotNull(defaultConstructor); + + // Test copy constructor + LongXorModification copy = new LongXorModification(modification); + assertEquals(modification.getXor(), copy.getXor()); + } +} diff --git a/src/test/java/de/rub/nds/modifiablevariable/mlong/ModifiableLongTest.java b/src/test/java/de/rub/nds/modifiablevariable/mlong/ModifiableLongTest.java index 4abfbb5f..1e1d5a5f 100644 --- a/src/test/java/de/rub/nds/modifiablevariable/mlong/ModifiableLongTest.java +++ b/src/test/java/de/rub/nds/modifiablevariable/mlong/ModifiableLongTest.java @@ -7,18 +7,22 @@ */ package de.rub.nds.modifiablevariable.mlong; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import de.rub.nds.modifiablevariable.longint.LongAddModification; import de.rub.nds.modifiablevariable.longint.ModifiableLong; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; public class ModifiableLongTest { private ModifiableLong long1; - private ModifiableLong long2; @BeforeEach @@ -30,55 +34,187 @@ public void setUp() { } /** Test of getAssertEquals method, of class ModifiableLong. */ - @Disabled("Not yet implemented") @Test - public void testGetAssertEquals() {} + public void testGetAssertEquals() { + assertNull(long1.getAssertEquals()); + long1.setAssertEquals(42L); + assertEquals(Long.valueOf(42L), long1.getAssertEquals()); + } /** Test of setAssertEquals method, of class ModifiableLong. */ - @Disabled("Not yet implemented") @Test - public void testSetAssertEquals() {} + public void testSetAssertEquals() { + long1.setAssertEquals(42L); + assertEquals(Long.valueOf(42L), long1.getAssertEquals()); + + long1.setAssertEquals(null); + assertNull(long1.getAssertEquals()); + } /** Test of isOriginalValueModified method, of class ModifiableLong. */ - @Disabled("Not yet implemented") @Test - public void testIsOriginalValueModified() {} + public void testIsOriginalValueModified() { + // Initial state - not modified + assertFalse(long1.isOriginalValueModified()); + + // After modification + long1.setModifications(new LongAddModification(1L)); + assertTrue(long1.isOriginalValueModified()); + + // Null original value + ModifiableLong nullLong = new ModifiableLong(); + assertFalse(nullLong.isOriginalValueModified()); + } /** Test of getByteArray method, of class ModifiableLong. */ - @Disabled("Not yet implemented") @Test - public void testGetByteArray() {} + public void testGetByteArray() { + // Test 8-byte representation + byte[] expected8 = new byte[] {0, 0, 0, 0, 0, 0, 0, 2}; + assertArrayEquals(expected8, long1.getByteArray(8)); + + // Test 4-byte representation (truncation) + byte[] expected4 = new byte[] {0, 0, 0, 2}; + assertArrayEquals(expected4, long1.getByteArray(4)); + + // Test with modified value + long1.setModifications(new LongAddModification(1L)); + byte[] expectedModified = new byte[] {0, 0, 0, 0, 0, 0, 0, 3}; + assertArrayEquals(expectedModified, long1.getByteArray(8)); + } /** Test of validateAssertions method, of class ModifiableLong. */ - @Disabled("Not yet implemented") @Test - public void testValidateAssertions() {} + public void testValidateAssertions() { + // No assertions set + assertTrue(long1.validateAssertions()); + + // Matching assertion + long1.setAssertEquals(2L); + assertTrue(long1.validateAssertions()); + + // Non-matching assertion + long1.setAssertEquals(3L); + assertFalse(long1.validateAssertions()); + + // Modified value matching assertion + long1.setAssertEquals(3L); + long1.setModifications(new LongAddModification(1L)); + assertTrue(long1.validateAssertions()); + } /** Test of getOriginalValue method, of class ModifiableLong. */ - @Disabled("Not yet implemented") @Test - public void testGetOriginalValue() {} + public void testGetOriginalValue() { + assertEquals(2L, long1.getOriginalValue()); + + ModifiableLong nullLong = new ModifiableLong(); + assertNull(nullLong.getOriginalValue()); + } /** Test of setOriginalValue method, of class ModifiableLong. */ - @Disabled("Not yet implemented") @Test - public void testSetOriginalValue() {} + public void testSetOriginalValue() { + long1.setOriginalValue(42L); + assertEquals(42L, long1.getOriginalValue()); + + long1.setOriginalValue(null); + assertNull(long1.getOriginalValue()); + } /** Test of toString method, of class ModifiableLong. */ - @Disabled("Not yet implemented") @Test - public void testToString() {} + public void testToString() { + String expected = "ModifiableLong{originalValue=2}"; + assertEquals(expected, long1.toString()); + + // With modification + long1.setModifications(new LongAddModification(1L)); + String expectedWithMod = + "ModifiableLong{originalValue=2, modifications=[LongAddModification{summand=1}]}"; + assertEquals(expectedWithMod, long1.toString()); + + // With assertion + long1.setAssertEquals(3L); + String expectedWithAssert = + "ModifiableLong{originalValue=2, modifications=[LongAddModification{summand=1}], assertEquals=3}"; + assertEquals(expectedWithAssert, long1.toString()); + } /** Test of equals method, of class ModifiableLong. */ @Test public void testEquals() { assertEquals(long1, long2); + + // Different original value but same computed value + long2.setOriginalValue(1L); + long2.setModifications(new LongAddModification(1L)); + assertEquals(long1, long2); + + // Different computed value long2.setOriginalValue(3L); assertNotEquals(long1, long2); + + // Test with null + assertNotEquals(long1, null); + + // Test with different object type + assertNotEquals(long1, "not a ModifiableLong"); + + // Test reflexivity + assertEquals(long1, long1); + + // Test with null values + ModifiableLong nullLong1 = new ModifiableLong(); + ModifiableLong nullLong2 = new ModifiableLong(); + assertEquals(nullLong1, nullLong2); } /** Test of hashCode method, of class ModifiableLong. */ - @Disabled("Not yet implemented") @Test - public void testHashCode() {} + public void testHashCode() { + assertEquals(long1.hashCode(), long2.hashCode()); + + // Same computed value, different original + long2.setOriginalValue(1L); + long2.setModifications(new LongAddModification(1L)); + assertEquals(long1.hashCode(), long2.hashCode()); + + // Different computed value + long2.setOriginalValue(3L); + assertNotEquals(long1.hashCode(), long2.hashCode()); + + // Test with null value + ModifiableLong nullLong = new ModifiableLong(); + } + + @Test + public void testCreateCopy() { + ModifiableLong copy = long1.createCopy(); + assertEquals(long1, copy); + assertEquals(long1.getOriginalValue(), copy.getOriginalValue()); + + // Modify the original and verify copy is unchanged + long1.setModifications(new LongAddModification(1L)); + assertNotEquals(long1.getValue(), copy.getValue()); + assertNotSame(long1, copy); + } + + @Test + public void testConstructor() { + ModifiableLong defaultConstructor = new ModifiableLong(); + assertNull(defaultConstructor.getOriginalValue()); + + ModifiableLong valueConstructor = new ModifiableLong(5L); + assertEquals(5L, valueConstructor.getOriginalValue()); + + ModifiableLong modLong = new ModifiableLong(5L); + modLong.setModifications(new LongAddModification(10L)); + modLong.setAssertEquals(15L); + + ModifiableLong copyConstructor = new ModifiableLong(modLong); + assertEquals(modLong.getOriginalValue(), copyConstructor.getOriginalValue()); + assertEquals(modLong.getValue(), copyConstructor.getValue()); + assertEquals(modLong.getAssertEquals(), copyConstructor.getAssertEquals()); + } }