bufferIndex += this.securityDescriptor.decode(buffer, bufferIndex, len);
        } catch (final IOException ioe) {
            throw new RuntimeCIFSException(ioe.getMessage());
        }

        return bufferIndex - start;
    }

    @Override
    public String toString() {
        return ("NtTransQuerySecurityResponse[" + super.toString() + "]");
    }

                artifact.updateVersion(version, request.getLocalRepository());
            } catch (RepositoryMetadataResolutionException e) {
                throw new ArtifactResolutionException(e.getMessage(), artifact, e);
            }
        }
    }

    @Override
    public void transformForInstall(Artifact artifact, ArtifactRepository localRepository) {

            parser.parse(new InputSource(new StringReader(invalidXml)));
            fail("Should throw GsaConfigException");
        } catch (GsaConfigException e) {
            assertEquals("Failed to parse XML file.", e.getMessage());
        }
    }

    @Test
    public void test_parseWithMalformedXml() {
        GsaConfigParser parser = new GsaConfigParser();
        String malformedXml = "<?xml version=\"1.0\"?><eef><unclosed>";

                    "Should throw when structure size != 4");

            // Assert: message is meaningful
            assertEquals("Structure size is not 4", ex.getMessage());
        }

        @Test
        @DisplayName("Null buffer leads to NullPointerException from readInt2")
        void nullBuffer_throwsNPE() {
            // Arrange

        } catch (FessSystemException e) {
            assertTrue(e.getMessage().contains("Invalid pruned tag"));
        }

        try {
            PrunedTag.parse("[invalid]");
            fail("Should have thrown FessSystemException");
        } catch (FessSystemException e) {
            assertTrue(e.getMessage().contains("Invalid pruned tag"));
        }

        try {

    }

    @Test
    public void test_init() {
        try {
            fileTypeHelper.init();
        } catch (Exception e) {
            fail("init() should not throw an exception: " + e.getMessage());
        }
    }

    @Test
    public void test_add() {
        fileTypeHelper.add("application/pdf", "pdf");
        assertEquals("pdf", fileTypeHelper.get("application/pdf"));

            MalformedURLException ex =
                    assertThrows(MalformedURLException.class, () -> new SmbNamedPipe(url, SmbPipeResource.PIPE_TYPE_RDWR, ctx()));
            assertEquals("Named pipes are only valid on IPC$", ex.getMessage());
        }

        @Test
        @DisplayName("Null context throws NPE (invalid input)")
        void nullContextThrows() {

                        content = new String(InputStreamUtil.getBytes(entity.getContent()), Constants.UTF_8_CHARSET);
                    } catch (final IOException e) {
                        content = e.getMessage();
                    }
                    logger.warn("Failed to access to {}. The http status is {}.\n{}", tokenUrl, httpStatusCode, content);
                }
            });
        }

    void parseThrowsOnNull() {
        TestSpnegoToken t = new TestSpnegoToken();
        IOException ex = assertThrows(IOException.class, () -> t.parse(null), "parse should throw IOException on null");
        assertTrue(ex.getMessage().toLowerCase().contains("null"));
    }

    @Test
    @DisplayName("toByteArray returns empty when no mechanismToken")
    void toByteArrayWhenNull() {
        TestSpnegoToken t = new TestSpnegoToken();

            metadata.storeInLocalRepository(localRepo, localRepo);
            merged = true;
        } catch (Exception e) {
            throw new RepositoryException(e.getMessage(), e);
        }
    }

    @Override
    public boolean isMerged() {
        return merged;
    }

    @Override
    public String getGroupId() {
        return emptify(metadata.getGroupId());