stack.addFirst(element);
    }

    public Element pop() {
        Element element = stack.removeFirst();
        if (emptyPara(element)) {
            element.getParentNode().removeChild(element);
        }
        return element;
    }

    private boolean emptyPara(Element element) {
        if (!element.getTagName().equals("para")) {
            return false;
        }

    void testSignWithEmptyData() {
        // Arrange
        byte[] emptyData = new byte[0];
        int offset = 0;
        int length = 0;

        // Act
        signingDigest.sign(emptyData, offset, length, request, response);

        // Assert
        verify(signingDigest, times(1)).sign(emptyData, offset, length, request, response);
    }

    @Test

    void testEmptyInputHashing() {
        // Given
        byte[] emptyData = {};

        // When
        MessageDigest md4 = Crypto.getMD4();
        MessageDigest md5 = Crypto.getMD5();
        byte[] md4Hash = md4.digest(emptyData);
        byte[] md5Hash = md5.digest(emptyData);

        // Then
        assertNotNull(md4Hash);
        assertNotNull(md5Hash);

        }
    }

    @Test
    void testEmptyPac() {
        // Test that PAC with size <= 8 is rejected
        byte[] emptyData = new byte[8];

        PACDecodingException e = assertThrows(PACDecodingException.class, () -> new Pac(emptyData, keys));
        // Any PACDecodingException is acceptable for this test
        assertNotNull(e.getMessage());
    }

    @Test
    void testTooSmallPac() {

    }

    @Test
    @DisplayName("Test with empty data")
    void testWithEmptyData() {
        // Given
        byte[] emptyData = new byte[0];
        transCallNamedPipe = new TransCallNamedPipe(mockConfig, TEST_PIPE_NAME, emptyData, 0, 0);
        byte[] dst = new byte[10];

        // When
        int bytesWritten = transCallNamedPipe.writeDataWireFormat(dst, 0);

        // Then

        @Test
        @DisplayName("Should handle empty data array")
        void testEmptyDataArray() {
            byte[] emptyData = new byte[0];
            byte[] name = "TEST_DATA".getBytes(StandardCharsets.UTF_8);
            TestCreateContextRequest request = new TestCreateContextRequest(name, emptyData);

            assertNotNull(request.getData());
            assertEquals(0, request.getData().length);
        }

        rule.setRuleId("stateRule");
        rule.setResponseProcessor(new TestResponseProcessor("stateProcessor"));

        // Empty ResponseData
        ResponseData emptyData = new ResponseData();
        assertTrue(rule.match(emptyData));

        // ResponseData with only URL
        ResponseData urlOnlyData = new ResponseData();
        urlOnlyData.setUrl("http://example.com");

        }

        @Test
        @DisplayName("Should handle empty data")
        void testSetEmptyData() {
            byte[] emptyData = new byte[0];
            assertDoesNotThrow(() -> request.setData(emptyData, 0, 0));
        }

        @ParameterizedTest
        @DisplayName("Should handle various data sizes")
        @ValueSource(ints = { 0, 1, 100, 1024, 4096, 65536, 1048576 })

     */
    public void test_transform_variousResponseDataStates() {
        // Empty ResponseData - should return a valid ResultData with empty/null data
        ResponseData emptyData = new ResponseData();
        ResultData result1 = testTransformer.transform(emptyData);
        assertNotNull(result1);
        assertNotNull(result1.getData()); // Transform should return ResultData with some data

        // ResponseData with only URL