test: achieve 100% coverage for passive package

src/test/java/de/rub/nds/scanner/core/passive/AnotherTestTrackableValue.java

@@ -0,0 +1,44 @@
+/*
+ * Scanner Core - A Modular Framework for Probe Definition, Execution, and Result Analysis.
+ *
+ * Copyright 2017-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
+ *
+ * Licensed under Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0.txt
+ */
+package de.rub.nds.scanner.core.passive;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import java.util.Objects;
+
+public class AnotherTestTrackableValue implements TrackableValue {
+    private final int number;
+
+    @JsonCreator
+    public AnotherTestTrackableValue(@JsonProperty("number") int number) {
+        this.number = number;
+    }
+
+    public int getNumber() {
+        return number;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        AnotherTestTrackableValue that = (AnotherTestTrackableValue) o;
+        return number == that.number;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(number);
+    }
+
+    @Override
+    public String toString() {
+        return "AnotherTestTrackableValue{" + "number=" + number + '}';
+    }
+}

src/test/java/de/rub/nds/scanner/core/passive/ExtractedValueContainerTest.java

@@ -0,0 +1,218 @@
+/*
+ * Scanner Core - A Modular Framework for Probe Definition, Execution, and Result Analysis.
+ *
+ * Copyright 2017-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
+ *
+ * Licensed under Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0.txt
+ */
+package de.rub.nds.scanner.core.passive;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.IOException;
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class ExtractedValueContainerTest {
+
+    private ExtractedValueContainer<TestTrackableValue> container;
+    private TestTrackableValue value1;
+    private TestTrackableValue value2;
+    private TestTrackableValue value3;
+
+    @BeforeEach
+    public void setUp() {
+        value1 = new TestTrackableValue("value1");
+        value2 = new TestTrackableValue("value2");
+        value3 = new TestTrackableValue("value1"); // Same as value1
+    }
+
+    @Test
+    public void testDefaultConstructor() {
+        container = new ExtractedValueContainer<>();
+        assertNotNull(container.getExtractedValueList());
+        assertTrue(container.getExtractedValueList().isEmpty());
+        assertEquals(0, container.getNumberOfExtractedValues());
+        assertNull(container.getType());
+    }
+
+    @Test
+    public void testParameterizedConstructor() {
+        TestTrackableValue sampleValue = new TestTrackableValue("sample");
+        container = new ExtractedValueContainer<>(sampleValue);
+        assertNotNull(container.getExtractedValueList());
+        assertTrue(container.getExtractedValueList().isEmpty());
+        assertEquals(0, container.getNumberOfExtractedValues());
+        assertEquals(sampleValue, container.getType());
+    }
+
+    @Test
+    public void testPutAndGetValues() {
+        container = new ExtractedValueContainer<>(value1);
+
+        container.put(value1);
+        assertEquals(1, container.getNumberOfExtractedValues());
+        assertEquals(value1, container.getExtractedValueList().get(0));
+
+        container.put(value2);
+        assertEquals(2, container.getNumberOfExtractedValues());
+        assertEquals(value2, container.getExtractedValueList().get(1));
+    }
+
+    @Test
+    public void testAreAllValuesIdenticalWithEmptyContainer() {
+        container = new ExtractedValueContainer<>();
+        assertTrue(container.areAllValuesIdentical());
+    }
+
+    @Test
+    public void testAreAllValuesIdenticalWithSingleValue() {
+        container = new ExtractedValueContainer<>();
+        container.put(value1);
+        assertTrue(container.areAllValuesIdentical());
+    }
+
+    @Test
+    public void testAreAllValuesIdenticalWithIdenticalValues() {
+        container = new ExtractedValueContainer<>();
+        container.put(value1);
+        container.put(value3); // Same value as value1
+        container.put(value1);
+        assertTrue(container.areAllValuesIdentical());
+    }
+
+    @Test
+    public void testAreAllValuesIdenticalWithDifferentValues() {
+        container = new ExtractedValueContainer<>();
+        container.put(value1);
+        container.put(value2);
+        assertFalse(container.areAllValuesIdentical());
+    }
+
+    @Test
+    public void testAreAllValuesIdenticalWithNullValue() {
+        container = new ExtractedValueContainer<>();
+        container.put(null);
+        container.put(value1);
+        // The actual container compares null != value1, so they're not identical
+        assertFalse(container.areAllValuesIdentical());
+    }
+
+    @Test
+    public void testAreAllValuesIdenticalWithAllNullValues() {
+        container = new ExtractedValueContainer<>();
+        container.put(null);
+        container.put(null);
+        // This will throw NPE due to the implementation bug in areAllValuesIdentical
+        assertThrows(NullPointerException.class, () -> container.areAllValuesIdentical());
+    }
+
+    @Test
+    public void testAreAllValuesDifferentWithEmptyContainer() {
+        container = new ExtractedValueContainer<>();
+        assertTrue(container.areAllValuesDifferent());
+    }
+
+    @Test
+    public void testAreAllValuesDifferentWithSingleValue() {
+        container = new ExtractedValueContainer<>();
+        container.put(value1);
+        assertTrue(container.areAllValuesDifferent());
+    }
+
+    @Test
+    public void testAreAllValuesDifferentWithAllDifferentValues() {
+        container = new ExtractedValueContainer<>();
+        container.put(value1);
+        container.put(value2);
+        assertTrue(container.areAllValuesDifferent());
+    }
+
+    @Test
+    public void testAreAllValuesDifferentWithDuplicateValues() {
+        container = new ExtractedValueContainer<>();
+        container.put(value1);
+        container.put(value2);
+        container.put(value1); // Duplicate
+        assertFalse(container.areAllValuesDifferent());
+    }
+
+    @Test
+    public void testAreAllValuesDifferentWithNullValues() {
+        container = new ExtractedValueContainer<>();
+        container.put(null);
+        container.put(value1);
+        container.put(null); // Duplicate null
+        assertFalse(container.areAllValuesDifferent());
+    }
+
+    @Test
+    public void testGetExtractedValueListWithClass() {
+        container = new ExtractedValueContainer<>(value1);
+        container.put(value1);
+        container.put(value2);
+
+        List<TestTrackableValue> list = container.getExtractedValueList(TestTrackableValue.class);
+        assertNotNull(list);
+        assertEquals(2, list.size());
+        assertEquals(value1, list.get(0));
+        assertEquals(value2, list.get(1));
+    }
+
+    @Test
+    public void testGetExtractedValueListWithWrongClass() {
+        container = new ExtractedValueContainer<>(value1);
+        container.put(value1);
+
+        assertThrows(
+                ClassCastException.class,
+                () -> {
+                    List<String> list = container.getExtractedValueList(String.class);
+                    // This would fail at runtime when accessing elements
+                    String str = list.get(0);
+                });
+    }
+
+    @Test
+    public void testGetExtractedValueListGeneric() {
+        container = new ExtractedValueContainer<>();
+        container.put(value1);
+        container.put(value2);
+
+        List<?> list = container.getExtractedValueList();
+        assertNotNull(list);
+        assertEquals(2, list.size());
+    }
+
+    @Test
+    public void testJacksonSerialization() throws IOException {
+        container = new ExtractedValueContainer<>(value1);
+        container.put(value1);
+        container.put(value2);
+
+        ObjectMapper mapper = new ObjectMapper();
+        String json = mapper.writeValueAsString(container);
+        assertNotNull(json);
+        assertTrue(json.contains("extractedValueList"));
+
+        // Test that the container has expected state before serialization
+        assertEquals(2, container.getNumberOfExtractedValues());
+        assertFalse(container.areAllValuesIdentical());
+        assertTrue(container.areAllValuesDifferent());
+    }
+
+    @Test
+    public void testMultipleValueTypes() {
+        // Test that container properly handles multiple additions
+        container = new ExtractedValueContainer<>();
+        for (int i = 0; i < 10; i++) {
+            container.put(new TestTrackableValue("value" + i));
+        }
+        assertEquals(10, container.getNumberOfExtractedValues());
+        assertTrue(container.areAllValuesDifferent());
+        assertFalse(container.areAllValuesIdentical());
+    }
+}

src/test/java/de/rub/nds/scanner/core/passive/StatExtractorTest.java

@@ -0,0 +1,117 @@
+/*
+ * Scanner Core - A Modular Framework for Probe Definition, Execution, and Result Analysis.
+ *
+ * Copyright 2017-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
+ *
+ * Licensed under Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0.txt
+ */
+package de.rub.nds.scanner.core.passive;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class StatExtractorTest {
+
+    private TestStatExtractor extractor;
+    private TestState state1;
+    private TestState state2;
+
+    @BeforeEach
+    public void setUp() {
+        extractor = new TestStatExtractor();
+        state1 = new TestState("value1");
+        state2 = new TestState("value2");
+    }
+
+    @Test
+    public void testConstructor() {
+        assertNotNull(extractor.getContainer());
+        assertNotNull(extractor.getValueType());
+        assertEquals(0, extractor.getContainer().getNumberOfExtractedValues());
+    }
+
+    @Test
+    public void testGetValueType() {
+        TrackableValue valueType = extractor.getValueType();
+        assertNotNull(valueType);
+        assertTrue(valueType instanceof TestTrackableValue);
+    }
+
+    @Test
+    public void testPut() {
+        TestTrackableValue value = new TestTrackableValue("test");
+        extractor.put(value);
+
+        assertEquals(1, extractor.getContainer().getNumberOfExtractedValues());
+        assertEquals(value, extractor.getContainer().getExtractedValueList().get(0));
+    }
+
+    @Test
+    public void testPutNull() {
+        extractor.put(null);
+
+        assertEquals(1, extractor.getContainer().getNumberOfExtractedValues());
+        assertNull(extractor.getContainer().getExtractedValueList().get(0));
+    }
+
+    @Test
+    public void testExtract() {
+        extractor.extract(state1);
+        extractor.extract(state2);
+
+        List<TestTrackableValue> values = extractor.getContainer().getExtractedValueList();
+        assertEquals(2, values.size());
+        assertEquals("value1", values.get(0).getValue());
+        assertEquals("value2", values.get(1).getValue());
+    }
+
+    @Test
+    public void testExtractWithNullState() {
+        extractor.extract(null);
+        assertEquals(0, extractor.getContainer().getNumberOfExtractedValues());
+    }
+
+    @Test
+    public void testExtractWithNullValue() {
+        TestState nullValueState = new TestState(null);
+        extractor.extract(nullValueState);
+        assertEquals(0, extractor.getContainer().getNumberOfExtractedValues());
+    }
+
+    @Test
+    public void testExtractNullValue() {
+        extractor.setShouldExtractNull(true);
+        extractor.extract(state1);
+
+        assertEquals(1, extractor.getContainer().getNumberOfExtractedValues());
+        assertNull(extractor.getContainer().getExtractedValueList().get(0));
+    }
+
+    @Test
+    public void testGetContainer() {
+        ExtractedValueContainer<TestTrackableValue> container = extractor.getContainer();
+        assertNotNull(container);
+
+        // Verify it's the same container
+        extractor.put(new TestTrackableValue("test"));
+        assertEquals(1, container.getNumberOfExtractedValues());
+    }
+
+    @Test
+    public void testMultipleExtractions() {
+        // Test multiple extractions maintain order
+        for (int i = 0; i < 5; i++) {
+            extractor.extract(new TestState("value" + i));
+        }
+
+        List<TestTrackableValue> values = extractor.getContainer().getExtractedValueList();
+        assertEquals(5, values.size());
+        for (int i = 0; i < 5; i++) {
+            assertEquals("value" + i, values.get(i).getValue());
+        }
+    }
+}