Add comprehensive tests for ModifiableLong modifications

src/test/java/de/rub/nds/modifiablevariable/mlong/LongAddModificationTest.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.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());
+    }
+
+    @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());
+    }
+}

src/test/java/de/rub/nds/modifiablevariable/mlong/LongExplicitValueModificationTest.java

@@ -0,0 +1,95 @@
+/*
+ * 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.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());
+    }
+
+    @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());
+    }
+}

src/test/java/de/rub/nds/modifiablevariable/mlong/LongModificationFactoryTest.java

@@ -0,0 +1,185 @@
+/*
+ * 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.assertThrows;
+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.LongModificationFactory;
+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 java.lang.reflect.Constructor;
+import java.lang.reflect.Modifier;
+import org.junit.jupiter.api.Test;
+
+public class LongModificationFactoryTest {
+
+    @Test
+    public void testAddWithLong() {
+        Long summand = 10L;
+        VariableModification<Long> modification = LongModificationFactory.add(summand);
+
+        assertNotNull(modification);
+        assertTrue(modification instanceof LongAddModification);
+        assertEquals(summand, ((LongAddModification) modification).getSummand());
+    }
+
+    @Test
+    public void testAddWithString() {
+        String summandString = "10";
+        Long summand = 10L;
+        VariableModification<Long> modification = LongModificationFactory.add(summandString);
+
+        assertNotNull(modification);
+        assertTrue(modification instanceof LongAddModification);
+        assertEquals(summand, ((LongAddModification) modification).getSummand());
+    }
+
+    @Test
+    public void testAddWithInvalidString() {
+        assertThrows(NumberFormatException.class, () -> LongModificationFactory.add("invalid"));
+    }
+
+    @Test
+    public void testSubWithLong() {
+        Long subtrahend = 10L;
+        VariableModification<Long> modification = LongModificationFactory.sub(subtrahend);
+
+        assertNotNull(modification);
+        assertTrue(modification instanceof LongSubtractModification);
+        assertEquals(subtrahend, ((LongSubtractModification) modification).getSubtrahend());
+    }
+
+    @Test
+    public void testSubWithString() {
+        String subtrahendString = "10";
+        Long subtrahend = 10L;
+        VariableModification<Long> modification = LongModificationFactory.sub(subtrahendString);
+
+        assertNotNull(modification);
+        assertTrue(modification instanceof LongSubtractModification);
+        assertEquals(subtrahend, ((LongSubtractModification) modification).getSubtrahend());
+    }
+
+    @Test
+    public void testSubWithInvalidString() {
+        assertThrows(NumberFormatException.class, () -> LongModificationFactory.sub("invalid"));
+    }
+
+    @Test
+    public void testXorWithLong() {
+        Long xorValue = 10L;
+        VariableModification<Long> modification = LongModificationFactory.xor(xorValue);
+
+        assertNotNull(modification);
+        assertTrue(modification instanceof LongXorModification);
+        assertEquals(xorValue, ((LongXorModification) modification).getXor());
+    }
+
+    @Test
+    public void testXorWithString() {
+        String xorString = "10";
+        Long xorValue = 10L;
+        VariableModification<Long> modification = LongModificationFactory.xor(xorString);
+
+        assertNotNull(modification);
+        assertTrue(modification instanceof LongXorModification);
+        assertEquals(xorValue, ((LongXorModification) modification).getXor());
+    }
+
+    @Test
+    public void testXorWithInvalidString() {
+        assertThrows(NumberFormatException.class, () -> LongModificationFactory.xor("invalid"));
+    }
+
+    @Test
+    public void testSwapEndian() {
+        VariableModification<Long> modification = LongModificationFactory.swapEndian();
+
+        assertNotNull(modification);
+        assertTrue(modification instanceof LongSwapEndianModification);
+    }
+
+    @Test
+    public void testExplicitValueWithLong() {
+        Long explicitValue = 10L;
+        VariableModification<Long> modification =
+                LongModificationFactory.explicitValue(explicitValue);
+
+        assertNotNull(modification);
+        assertTrue(modification instanceof LongExplicitValueModification);
+        assertEquals(
+                explicitValue, ((LongExplicitValueModification) modification).getExplicitValue());
+    }
+
+    @Test
+    public void testExplicitValueWithString() {
+        String valueString = "10";
+        Long explicitValue = 10L;
+        VariableModification<Long> modification =
+                LongModificationFactory.explicitValue(valueString);
+
+        assertNotNull(modification);
+        assertTrue(modification instanceof LongExplicitValueModification);
+        assertEquals(
+                explicitValue, ((LongExplicitValueModification) modification).getExplicitValue());
+    }
+
+    @Test
+    public void testExplicitValueWithInvalidString() {
+        assertThrows(
+                NumberFormatException.class,
+                () -> LongModificationFactory.explicitValue("invalid"));
+    }
+
+    @Test
+    public void testMultiply() {
+        Long factor = 10L;
+        VariableModification<Long> modification = LongModificationFactory.multiply(factor);
+
+        assertNotNull(modification);
+        assertTrue(modification instanceof LongMultiplyModification);
+        assertEquals(factor, ((LongMultiplyModification) modification).getFactor());
+    }
+
+    @Test
+    public void testShiftLeft() {
+        int shift = 5;
+        VariableModification<Long> modification = LongModificationFactory.shiftLeft(shift);
+
+        assertNotNull(modification);
+        assertTrue(modification instanceof LongShiftLeftModification);
+        assertEquals(shift, ((LongShiftLeftModification) modification).getShift());
+    }
+
+    @Test
+    public void testShiftRight() {
+        int shift = 5;
+        VariableModification<Long> modification = LongModificationFactory.shiftRight(shift);
+
+        assertNotNull(modification);
+        assertTrue(modification instanceof LongShiftRightModification);
+        assertEquals(shift, ((LongShiftRightModification) modification).getShift());
+    }
+
+    @Test
+    public void testPrivateConstructor() throws NoSuchMethodException {
+        Constructor<LongModificationFactory> constructor =
+                LongModificationFactory.class.getDeclaredConstructor();
+        assertTrue(Modifier.isPrivate(constructor.getModifiers()));
+    }
+}