Merge branch 'main' into test/logging-coverage

Author: ic0ns

src/main/java/de/rub/nds/modifiablevariable/logging/ExtendedPatternLayout.java

@@ -147,6 +147,17 @@ public static ExtendedPatternLayout.SerializerBuilder newSerializerBuilder() {
         return new ExtendedPatternLayout.SerializerBuilder();
     }
 
+    /**
+     * Determines if this layout requires location information (i.e., class name, method name, line
+     * number).
+     *
+     * <p>Location information can be expensive to generate, so this method allows the logging
+     * framework to determine whether it needs to capture stack traces for log events processed by
+     * this layout.
+     *
+     * @return {@code true} if the configured event serializer requires location information, {@code
+     *     false} otherwise
+     */
     @Override
     public boolean requiresLocation() {
         return eventSerializer instanceof LocationAware
@@ -530,6 +541,14 @@ public ExtendedPatternLayout.Builder withFooter(String footer) {
             return this;
         }
 
+        /**
+         * Builds a new ExtendedPatternLayout instance with the configured settings.
+         *
+         * <p>This method creates a new layout using all the settings configured on this builder. If
+         * no configuration has been explicitly set, a default configuration will be used.
+         *
+         * @return A new ExtendedPatternLayout instance configured with the specified settings
+         */
         @Override
         public ExtendedPatternLayout build() {
             if (configuration == null) {
@@ -637,6 +656,20 @@ public SerializerBuilder() {
         private boolean disableAnsi;
         private boolean noConsoleNoAnsi;
 
+        /**
+         * Builds a serializer for formatting log events according to the configured settings.
+         *
+         * <p>This method creates an appropriate serializer based on the configured options:
+         *
+         * <ul>
+         *   <li>If both pattern and defaultPattern are empty, returns null
+         *   <li>If a patternSelector is configured, creates a PatternSelectorSerializer
+         *   <li>Otherwise, creates an ExtendedPatternLayoutSerializer based on the parsed pattern
+         * </ul>
+         *
+         * @return A configured serializer instance, or null if no pattern is available
+         * @throws IllegalArgumentException if the pattern cannot be parsed
+         */
         @Override
         public AbstractStringLayout.Serializer build() {
             if (Strings.isEmpty(pattern) && Strings.isEmpty(defaultPattern)) {

src/test/java/de/rub/nds/modifiablevariable/ModifiableVariableTest.java

@@ -84,4 +84,89 @@ public void testCopyConstructorWithModifications() {
         assertEquals(150, original.getValue());
         assertEquals(300, copy.getValue());
     }
+
+    /** Test getModifications method. */
+    @Test
+    public void testGetModifications() {
+        ModifiableInteger integer = new ModifiableInteger();
+        integer.setOriginalValue(100);
+
+        // Initially no modifications
+        assertNull(integer.getModifications());
+
+        // Add modifications
+        IntegerAddModification addMod = new IntegerAddModification(50);
+        IntegerMultiplyModification multiplyMod = new IntegerMultiplyModification(2);
+        integer.addModification(addMod);
+        integer.addModification(multiplyMod);
+
+        // Get modifications
+        List<VariableModification<Integer>> mods = integer.getModifications();
+        assertNotNull(mods);
+        assertEquals(2, mods.size());
+        assertEquals(addMod, mods.get(0));
+        assertEquals(multiplyMod, mods.get(1));
+
+        // Clear modifications
+        integer.clearModifications();
+        assertNull(integer.getModifications());
+    }
+
+    /** Test containsAssertion method. */
+    @Test
+    public void testContainsAssertion() {
+        ModifiableInteger integer = new ModifiableInteger();
+
+        // Initially no assertion
+        assertFalse(integer.containsAssertion());
+
+        // Set assertEquals value
+        integer.setAssertEquals(150);
+        assertTrue(integer.containsAssertion());
+
+        // Create new instance without assertion
+        ModifiableInteger noAssertion = new ModifiableInteger();
+        assertFalse(noAssertion.containsAssertion());
+    }
+
+    /** Test innerToString method through subclass toString. */
+    @Test
+    public void testInnerToString() {
+        // Test with no modifications or assertions
+        ModifiableInteger integer1 = new ModifiableInteger();
+        integer1.setOriginalValue(100);
+        String str1 = integer1.toString();
+        assertTrue(str1.contains("originalValue=100"));
+        assertFalse(str1.contains("modifications="));
+        assertFalse(str1.contains("assertEquals="));
+
+        // Test with modifications
+        ModifiableInteger integer2 = new ModifiableInteger();
+        integer2.setOriginalValue(100);
+        integer2.addModification(new IntegerAddModification(50));
+        integer2.addModification(new IntegerMultiplyModification(2));
+        String str2 = integer2.toString();
+        assertTrue(str2.contains("originalValue=100"));
+        assertTrue(str2.contains("modifications=["));
+        assertTrue(str2.contains("IntegerAddModification"));
+        assertTrue(str2.contains("IntegerMultiplyModification"));
+
+        // Test with assertions
+        ModifiableInteger integer3 = new ModifiableInteger();
+        integer3.setOriginalValue(100);
+        integer3.setAssertEquals(150);
+        String str3 = integer3.toString();
+        assertTrue(str3.contains("originalValue=100"));
+        assertTrue(str3.contains("assertEquals=150"));
+
+        // Test with both modifications and assertions
+        ModifiableInteger integer4 = new ModifiableInteger();
+        integer4.setOriginalValue(100);
+        integer4.addModification(new IntegerAddModification(50));
+        integer4.setAssertEquals(150);
+        String str4 = integer4.toString();
+        assertTrue(str4.contains("originalValue=100"));
+        assertTrue(str4.contains("modifications=["));
+        assertTrue(str4.contains("assertEquals=150"));
+    }
 }