Added unit tests

Author: p-huynh

src/main/java/de/rub/nds/protocol/util/SilentByteArrayOutputStream.java

@@ -1,7 +1,7 @@
 /*
  * Protocol-Attacker - A Framework to create Protocol Analysis Tools
  *
- * Copyright 2023-2024 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
+ * Copyright 2023-2025 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
@@ -118,8 +118,8 @@ public void writeTo(OutputStream out) {
         try {
             this.outputStream.writeTo(out);
         } catch (IOException ex) {
-            LOGGER.warn("Encountered exception while writing to OutputStream.");
-            LOGGER.debug(ex);
+            LOGGER.error("Encountered exception while writing to OutputStream.", ex);
+            throw new RuntimeException(ex);
         }
     }
 

src/test/java/de/rub/nds/protocol/util/SilentByteArrayOutputStreamTest.java

@@ -0,0 +1,130 @@
+/*
+ * Protocol-Attacker - A Framework to create Protocol Analysis Tools
+ *
+ * Copyright 2023-2025 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.protocol.util;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.io.ByteArrayOutputStream;
+import java.nio.charset.StandardCharsets;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class SilentByteArrayOutputStreamTest {
+
+    private SilentByteArrayOutputStream stream;
+
+    @BeforeEach
+    public void setUp() {
+        stream = new SilentByteArrayOutputStream();
+    }
+
+    @Test
+    public void testDefaultConstructor() {
+        assertNotNull(stream);
+        assertEquals(0, stream.size());
+    }
+
+    @Test
+    public void testSizedConstructor() {
+        SilentByteArrayOutputStream sizedStream = new SilentByteArrayOutputStream(64);
+        assertNotNull(sizedStream);
+        assertEquals(0, sizedStream.size());
+    }
+
+    @Test
+    public void testWriteSingleByte() {
+        stream.write(0x04);
+        assertEquals(1, stream.size());
+        assertEquals((byte) 0x04, stream.toByteArray()[0]);
+    }
+
+    @Test
+    public void testWriteByteArray() {
+        byte[] data = {0x01, 0x02, 0x03, 0x04};
+        stream.write(data);
+        assertEquals(4, stream.size());
+        assertArrayEquals(data, stream.toByteArray());
+    }
+
+    @Test
+    public void testWriteByteArrayWithOffsetAndLength() {
+        byte[] data = {0x01, 0x02, 0x03, 0x04};
+        stream.write(data, 1, 2);
+        assertArrayEquals(new byte[] {0x02, 0x03}, stream.toByteArray());
+    }
+
+    @Test
+    public void testWriteBytes() {
+        byte[] data = {0x01, 0x02, 0x03, 0x04};
+        stream.writeBytes(data);
+        assertArrayEquals(data, stream.toByteArray());
+    }
+
+    @Test
+    public void testWriteTo() {
+        byte[] data = {0x01, 0x02, 0x03, 0x04};
+        stream.write(data);
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        stream.writeTo(out);
+        assertArrayEquals(data, out.toByteArray());
+    }
+
+    @Test
+    public void testReset() {
+        byte[] data = {0x01, 0x02, 0x03, 0x04};
+        stream.write(data);
+        assertEquals(4, stream.size());
+        stream.reset();
+        assertEquals(0, stream.size());
+    }
+
+    @Test
+    public void testToByteArray() {
+        stream.write(new byte[] {0x01, 0x02});
+        byte[] result = stream.toByteArray();
+        assertArrayEquals(new byte[] {0x01, 0x02}, result);
+    }
+
+    @Test
+    public void testToStringDefaultCharset() {
+        String testString = "Test";
+        stream.write(testString.getBytes(StandardCharsets.UTF_8));
+        assertEquals(testString, stream.toString());
+    }
+
+    @Test
+    public void testToStringWithCharsetName() {
+        String testString = "Test";
+        stream.write(testString.getBytes(StandardCharsets.UTF_8));
+        assertEquals(testString, stream.toString("UTF-8"));
+    }
+
+    @Test
+    public void testToStringWithCharset() {
+        String testString = "Test";
+        stream.write(testString.getBytes(StandardCharsets.UTF_8));
+        assertEquals(testString, stream.toString(StandardCharsets.UTF_8));
+    }
+
+    @Test
+    @SuppressWarnings("deprecation")
+    public void testToStringWithHighByte() {
+        stream.write(new byte[] {0x54, 0x65, 0x73, 0x74}); // Test
+        String result = stream.toString(0);
+        assertEquals(4, result.length());
+    }
+
+    @Test
+    public void testCloseDoesNothing() {
+        stream.write(0x01);
+        assertDoesNotThrow(() -> stream.close());
+        stream.write(0x02);
+        assertEquals(2, stream.size());
+    }
+}