Refactoring + Insert Modification for Strings, Integer, BigInteger, Long + Some more Modifications for Long

src/main/java/de/rub/nds/modifiablevariable/ModifiableVariable.java

@@ -39,6 +39,7 @@
 import de.rub.nds.modifiablevariable.singlebyte.ByteXorModification;
 import de.rub.nds.modifiablevariable.string.StringAppendValueModification;
 import de.rub.nds.modifiablevariable.string.StringExplicitValueModification;
+import de.rub.nds.modifiablevariable.string.StringInsertValueModification;
 import de.rub.nds.modifiablevariable.string.StringPrependValueModification;
 import jakarta.xml.bind.annotation.XmlAccessType;
 import jakarta.xml.bind.annotation.XmlAccessorType;
@@ -149,7 +150,10 @@ public abstract class ModifiableVariable<E> implements Serializable {
                         name = "StringAppendValueModification"),
                 @XmlElement(
                         type = StringExplicitValueModification.class,
-                        name = "StringExplicitValueModification")
+                        name = "StringExplicitValueModification"),
+                @XmlElement(
+                        type = StringInsertValueModification.class,
+                        name = "StringInsertValueModification")
             })
     private VariableModification<E> modification = null;
 

src/main/java/de/rub/nds/modifiablevariable/VariableModification.java

@@ -41,7 +41,7 @@ public abstract class VariableModification<E> {
 
     public E modify(E input) {
         E modifiedValue = modifyImplementationHook(input);
-        if ((modificationFilter == null) || (modificationFilter.filterModification() == false)) {
+        if ((modificationFilter == null) || (!modificationFilter.filterModification())) {
             debug(modifiedValue);
             return modifiedValue;
         } else {

src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerAddModification.java

@@ -69,9 +69,6 @@ public boolean equals(Object obj) {
             return false;
         }
         final BigIntegerAddModification other = (BigIntegerAddModification) obj;
-        if (!Objects.equals(this.summand, other.summand)) {
-            return false;
-        }
-        return true;
+        return Objects.equals(this.summand, other.summand);
     }
 }

src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerExplicitValueModification.java

@@ -75,9 +75,6 @@ public boolean equals(Object obj) {
             return false;
         }
         final BigIntegerExplicitValueModification other = (BigIntegerExplicitValueModification) obj;
-        if (!Objects.equals(this.explicitValue, other.explicitValue)) {
-            return false;
-        }
-        return true;
+        return Objects.equals(this.explicitValue, other.explicitValue);
     }
 }

src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerModificationFactory.java

@@ -24,7 +24,11 @@
 
 public class BigIntegerModificationFactory {
 
-    private static final int MODIFICATION_COUNT = 7;
+    private enum ModificationType {
+        ADD, SUBTRACT, XOR, EXPLICIT, SHIFT_LEFT, SHIFT_RIGHT, EXPLICIT_FROM_FILE
+    }
+
+    private static final int MODIFICATION_COUNT = ModificationType.values().length;
 
     private static final int MAX_MODIFICATION_VALUE = 320000;
 
@@ -138,7 +142,7 @@ public static synchronized List<VariableModification<BigInteger>> modificationsF
                 String line;
                 while ((line = br.readLine()) != null) {
                     String value = line.trim().split(" ")[0];
-                    if (!value.equals("")) {
+                    if (!value.isEmpty()) {
                         modificationsFromFile.add(explicitValue(value));
                     }
                 }
@@ -152,35 +156,26 @@ public static synchronized List<VariableModification<BigInteger>> modificationsF
 
     public static VariableModification<BigInteger> createRandomModification() {
         Random random = RandomHelper.getRandom();
-        int r = random.nextInt(MODIFICATION_COUNT);
+        ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)];
         BigInteger modification = BigInteger.valueOf(random.nextInt(MAX_MODIFICATION_VALUE));
         int shiftModification = random.nextInt(MAX_MODIFICATION_SHIFT_VALUE);
-        VariableModification<BigInteger> vm = null;
-        switch (r) {
-            case 0:
-                vm = new BigIntegerAddModification(modification);
-                return vm;
-            case 1:
-                vm = new BigIntegerSubtractModification(modification);
-                return vm;
-            case 2:
-                vm = new BigIntegerXorModification(modification);
-                return vm;
-            case 3:
-                vm = new BigIntegerExplicitValueModification(modification);
-                return vm;
-            case 4:
-                vm = new BigIntegerShiftLeftModification(shiftModification);
-                return vm;
-            case 5:
-                vm = new BigIntegerShiftRightModification(shiftModification);
-                return vm;
-            case 6:
-                vm = explicitValueFromFile(MAX_MODIFICATION_VALUE);
-                return vm;
-            default: // unreachable but included for checkstyle
-                vm = explicitValueFromFile(MAX_MODIFICATION_VALUE);
-                return vm;
+        switch (randomType) {
+            case ADD:
+                return new BigIntegerAddModification(modification);
+            case SUBTRACT:
+                return new BigIntegerSubtractModification(modification);
+            case XOR:
+                return new BigIntegerXorModification(modification);
+            case EXPLICIT:
+                return new BigIntegerExplicitValueModification(modification);
+            case SHIFT_LEFT:
+                return new BigIntegerShiftLeftModification(shiftModification);
+            case SHIFT_RIGHT:
+                return new BigIntegerShiftRightModification(shiftModification);
+            case EXPLICIT_FROM_FILE:
+                return explicitValueFromFile(MAX_MODIFICATION_VALUE);
+            default:
+                throw new IllegalStateException("Unexpected modification type: " + randomType);
         }
     }
 

src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerMultiplyModification.java

@@ -72,9 +72,6 @@ public boolean equals(Object obj) {
             return false;
         }
         final BigIntegerMultiplyModification other = (BigIntegerMultiplyModification) obj;
-        if (!Objects.equals(this.factor, other.factor)) {
-            return false;
-        }
-        return true;
+        return Objects.equals(this.factor, other.factor);
     }
 }

src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftLeftModification.java

@@ -70,9 +70,6 @@ public boolean equals(Object obj) {
             return false;
         }
         final BigIntegerShiftLeftModification other = (BigIntegerShiftLeftModification) obj;
-        if (this.shift != other.shift) {
-            return false;
-        }
-        return true;
+        return this.shift == other.shift;
     }
 }

src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerShiftRightModification.java

@@ -70,9 +70,6 @@ public boolean equals(Object obj) {
             return false;
         }
         final BigIntegerShiftRightModification other = (BigIntegerShiftRightModification) obj;
-        if (this.shift != other.shift) {
-            return false;
-        }
-        return true;
+        return this.shift == other.shift;
     }
 }

src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerSubtractModification.java

@@ -72,9 +72,6 @@ public boolean equals(Object obj) {
             return false;
         }
         final BigIntegerSubtractModification other = (BigIntegerSubtractModification) obj;
-        if (!Objects.equals(this.subtrahend, other.subtrahend)) {
-            return false;
-        }
-        return true;
+        return Objects.equals(this.subtrahend, other.subtrahend);
     }
 }

src/main/java/de/rub/nds/modifiablevariable/biginteger/BigIntegerXorModification.java

@@ -71,9 +71,6 @@ public boolean equals(Object obj) {
             return false;
         }
         final BigIntegerXorModification other = (BigIntegerXorModification) obj;
-        if (!Objects.equals(this.xor, other.xor)) {
-            return false;
-        }
-        return true;
+        return Objects.equals(this.xor, other.xor);
     }
 }

src/main/java/de/rub/nds/modifiablevariable/biginteger/ModifiableBigInteger.java

@@ -52,9 +52,7 @@ public byte[] getByteArray(int size) {
     @Override
     public boolean validateAssertions() {
         if (assertEquals != null) {
-            if (assertEquals.compareTo(getValue()) != 0) {
-                return false;
-            }
+            return assertEquals.compareTo(getValue()) == 0;
         }
         return true;
     }

src/main/java/de/rub/nds/modifiablevariable/bool/BooleanExplicitValueModification.java

@@ -60,10 +60,7 @@ public boolean equals(Object obj) {
             return false;
         }
         final BooleanExplicitValueModification other = (BooleanExplicitValueModification) obj;
-        if (this.explicitValue != other.explicitValue) {
-            return false;
-        }
-        return true;
+        return this.explicitValue == other.explicitValue;
     }
 
     @Override

src/main/java/de/rub/nds/modifiablevariable/bool/BooleanModificationFactory.java

@@ -13,19 +13,23 @@
 
 public class BooleanModificationFactory {
 
-    private static final int MODIFICATION_COUNT = 3;
+    private enum ModificationType {
+        EXPLICIT_TRUE, EXPLICIT_FALSE, TOGGLE
+    }
+    private static final int MODIFICATION_COUNT = ModificationType.values().length;
 
     public static VariableModification<Boolean> createRandomModification() {
         Random random = RandomHelper.getRandom();
-        switch (random.nextInt(MODIFICATION_COUNT)) {
-            case 0:
+        ModificationType randomType = ModificationType.values()[random.nextInt(MODIFICATION_COUNT)];
+        switch (randomType) {
+            case EXPLICIT_TRUE:
                 return new BooleanExplicitValueModification(true);
-            case 1:
+            case EXPLICIT_FALSE:
                 return new BooleanExplicitValueModification(false);
-            case 2:
+            case TOGGLE:
                 return new BooleanToggleModification();
             default:
-                return null;
+                throw new IllegalStateException("Unexpected modification type: " + randomType);
         }
     }
 

src/main/java/de/rub/nds/modifiablevariable/bool/BooleanToggleModification.java

@@ -44,10 +44,7 @@ public boolean equals(Object obj) {
         if (obj == null) {
             return false;
         }
-        if (getClass() != obj.getClass()) {
-            return false;
-        }
-        return true;
+        return getClass() == obj.getClass();
     }
 
     @Override

src/main/java/de/rub/nds/modifiablevariable/bool/ModifiableBoolean.java

@@ -49,9 +49,7 @@ public boolean isOriginalValueModified() {
     @Override
     public boolean validateAssertions() {
         if (assertEquals != null) {
-            if (assertEquals.compareTo(getValue()) != 0) {
-                return false;
-            }
+            return assertEquals.compareTo(getValue()) == 0;
         }
         return true;
     }

src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDeleteModification.java

@@ -45,22 +45,17 @@ protected byte[] modifyImplementationHook(byte[] input) {
         if (start < 0) {
             start += input.length;
             if (start < 0) {
-                LOGGER.debug(
-                        "Trying to delete from too negative Startposition. start = "
-                                + (start - input.length));
+                LOGGER.debug("Trying to delete from too negative Startposition. start = {}", start - input.length);
                 return input;
             }
         }
         final int endPosition = start + count;
         if ((endPosition) > input.length) {
-            LOGGER.debug(
-                    String.format(
-                            "Bytes %d..%d cannot be deleted from {%s} of length %d",
-                            start, endPosition, bytesToHexString(input), input.length));
+            LOGGER.debug("Bytes {}..{} cannot be deleted from {{}} of length {}", start, endPosition, bytesToHexString(input), input.length);
             return input;
         }
         if (count <= 0) {
-            LOGGER.debug("You must delete at least one byte. count = " + count);
+            LOGGER.debug("You must delete at least one byte. count = {}", count);
             return input;
         }
         byte[] ret1 = Arrays.copyOf(input, start);
@@ -132,10 +127,7 @@ public boolean equals(Object obj) {
         if (this.count != other.count) {
             return false;
         }
-        if (this.startPosition != other.startPosition) {
-            return false;
-        }
-        return true;
+        return this.startPosition == other.startPosition;
     }
 
     @Override

src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayDuplicateModification.java

@@ -48,10 +48,7 @@ public boolean equals(Object obj) {
         if (obj == null) {
             return false;
         }
-        if (getClass() != obj.getClass()) {
-            return false;
-        }
-        return true;
+        return getClass() == obj.getClass();
     }
 
     @Override

src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayExplicitValueModification.java

@@ -86,9 +86,6 @@ public boolean equals(Object obj) {
             return false;
         }
         final ByteArrayExplicitValueModification other = (ByteArrayExplicitValueModification) obj;
-        if (!Arrays.equals(this.explicitValue, other.explicitValue)) {
-            return false;
-        }
-        return true;
+        return Arrays.equals(this.explicitValue, other.explicitValue);
     }
 }

src/main/java/de/rub/nds/modifiablevariable/bytearray/ByteArrayInsertModification.java

@@ -49,23 +49,17 @@ protected byte[] modifyImplementationHook(byte[] input) {
         if (start < 0) {
             start += input.length;
             if (start < 0) {
-                LOGGER.debug(
-                        "Trying to insert from too negative Startposition. start = "
-                                + startPosition);
+                LOGGER.debug("Trying to insert from too negative Startposition. start = {}", startPosition);
                 return input;
             }
         }
-        if (startPosition > input.length) {
-            LOGGER.debug(
-                    "Trying to insert behind the Array. ArraySize:"
-                            + input.length
-                            + " Insert Position:"
-                            + startPosition);
+        if (start > input.length) {
+            LOGGER.debug("Trying to insert behind the Array. ArraySize:{} Insert Position:{}", input.length, startPosition);
             return input;
         }
         byte[] ret1 = Arrays.copyOf(input, start);
         byte[] ret3 = null;
-        if ((start) < input.length) {
+        if (start < input.length) {
             ret3 = Arrays.copyOfRange(input, start, input.length);
         }
         return ArrayConverter.concatenate(ret1, bytesToInsert, ret3);
@@ -133,10 +127,7 @@ public boolean equals(Object obj) {
         if (this.startPosition != other.startPosition) {
             return false;
         }
-        if (!Arrays.equals(this.bytesToInsert, other.bytesToInsert)) {
-            return false;
-        }
-        return true;
+        return Arrays.equals(this.bytesToInsert, other.bytesToInsert);
     }
 
     @Override