close #251: Allow softhyphen in form field names

Fix PDFDocEncoding: decode 0xAD to U+00AD (SOFT HYPHEN), not NUL

Byte 0xAD was skipped during table init and left unmapped in CODE_TO_UNI,
so it decoded to (char) 0 (U+0000) instead of the soft hyphen. This
corrupted text strings such as form field names and broke field lookups against producers
that decode 0xAD as U+00AD (eg: pdf.js).

Stop skipping 0xAD so it maps to its ISO-8859-1 value U+00AD; it now
round-trips and encodes back to a single 0xAD byte.

Adds round-trip tests for the soft hyphen and the field-name case, plus
regression locks for undefined bytes (0x7F/0x9F -> U+FFFD) and NUL
(0x00 -> U+0000).

Author: ediweissmann

src/main/java/org/sejda/sambox/cos/PDFDocEncoding.java

@@ -49,10 +49,6 @@ final class PDFDocEncoding
             {
                 continue;
             }
-            if (i == 0xAD)
-            {
-                continue;
-            }
 
             set(i, (char) i);
         }

src/test/java/org/sejda/sambox/cos/PDFDocEncodingTest.java

@@ -17,6 +17,7 @@
 
 package org.sejda.sambox.cos;
 
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
 import java.io.IOException;
@@ -108,4 +109,64 @@ public void testPDFBox3864() throws IOException
             assertEquals(cs1.getString(), cs2.getString());
         }
     }
+
+    /**
+     * 0xAD (SOFT HYPHEN) must decode to U+00AD, not U+0000. ISO 32000-1 leaves it undefined, but
+     * other producers treat it as its ISO-8859-1 value; decoding it to a
+     * NUL control character corrupts text strings such as form field names.
+     */
+    @Test
+    public void softHyphenDecodesToU00AD()
+    {
+        assertEquals("\u00AD", PDFDocEncoding.toString(new byte[] { (byte) 0xAD }));
+    }
+
+    @Test
+    public void softHyphenEncodesTo0xAD()
+    {
+        assertArrayEquals(new byte[] { (byte) 0xAD }, PDFDocEncoding.getBytes("\u00AD"));
+    }
+
+    @Test
+    public void softHyphenRoundTrips()
+    {
+        byte[] bytes = { (byte) 0xAD };
+        assertArrayEquals(bytes, PDFDocEncoding.getBytes(PDFDocEncoding.toString(bytes)));
+    }
+
+    /**
+     * Reproduces the real-world failure: a German field name with two soft hyphens and an
+     * a-umlaut, stored as PDFDocEncoding, survives a literal round-trip via COSString and is
+     * stored single-byte (not UTF-16BE).
+     */
+    @Test
+    public void fieldNameWithSoftHyphensRoundTrips()
+    {
+        String fieldName = "Test\u00ADbesch\u00E4test adas Test\u00ADdsadas";
+        COSString cosString = COSString.parseLiteral(fieldName);
+        assertEquals(fieldName, cosString.getString());
+        // representable in PDFDocEncoding, so single-byte; UTF-16BE would be 2*len + 2 (BOM)
+        assertEquals(fieldName.length(), cosString.getBytes().length);
+    }
+
+    /**
+     * Bytes genuinely undefined in PDFDocEncoding (0x7F, 0x9F) must decode to the replacement
+     * character, never to a silent U+0000.
+     */
+    @Test
+    public void undefinedBytesDecodeToReplacementCharacter()
+    {
+        assertEquals("\uFFFD", PDFDocEncoding.toString(new byte[] { (byte) 0x7F }));
+        assertEquals("\uFFFD", PDFDocEncoding.toString(new byte[] { (byte) 0x9F }));
+    }
+
+    /**
+     * Code 0x00 is a legitimate mapping to U+0000 and must not be clobbered by the
+     * replacement-character pre-fill.
+     */
+    @Test
+    public void nulByteStillDecodesToU0000()
+    {
+        assertEquals("\u0000", PDFDocEncoding.toString(new byte[] { 0x00 }));
+    }
 }