doThrow(expectedException).when(spyHandle).sendrecv(any(DcerpcMessage.class));

            // When/Then: Should propagate IOException
            IOException thrown = assertThrows(IOException.class, () -> spyHandle.bind());
            assertEquals("Test IO Exception", thrown.getMessage());
        }
    }

    @Nested
    @DisplayName("Send/Receive Tests")
    class SendReceiveTests {

        @Test

   * (<code>'&#92;u002D'</code>) is recognized as the minus sign.
   *
   * <p>Unlike {@link Integer#parseInt(String)}, this method returns {@code null} instead of
   * throwing an exception if parsing fails. Additionally, this method only accepts ASCII digits,
   * and returns {@code null} if non-ASCII digits are present in the string.
   *

import jcifs.dcerpc.UnicodeString;
import jcifs.dcerpc.msrpc.LsaPolicyHandle;
import jcifs.dcerpc.msrpc.lsarpc;

@ExtendWith(MockitoExtension.class)
class SIDCacheImplTest {

    // Helper to create a SID from text without throwing in the test body
    private static SID sid(String textual) {
        try {
            return new SID(textual);
        } catch (SmbException e) {
            throw new RuntimeException(e);
        }
    }

            // Then
            assertEquals(42, result);
            verify(mockAllocInfo, times(1)).decode(buffer, 10, 50);
        }

        @Test
        @DisplayName("Should handle decode method throwing exception")
        void shouldHandleDecodeMethodThrowingException() throws jcifs.internal.SMBProtocolDecodingException {
            // Given
            byte[] buffer = new byte[100];

    //                                                                        ============

    /**
     * Verifies that the current CRUD mode matches the expected mode, throwing a validation error if not.
     *
     * @param crudMode   the actual CRUD mode value
     * @param expectedMode the expected CRUD mode value
     */

        Artifact artifact = new Artifact("fess-ds-test", "1.0.0", "http://test.com/test.jar");

        try {
            testHelper.installArtifact(artifact);
            // If we get here, the method executed without throwing
            assertTrue(true);
        } catch (Exception e) {
            fail("Unexpected exception: " + e.getMessage());
        }
    }

    public void test_install_blankUrl() {

     * specified by the <code>UniAddress</code> parameter. If the credentials are
     * not accepted, an <code>SmbAuthException</code> will be thrown. If an error
     * occurs an <code>SmbException</code> will be thrown. If the credentials are
     * valid, the method will return without throwing an exception. See the
     * last <a href="../../../faq.html">FAQ</a> question.
     * <p>

      s.addValue("removalListener");
    }
    return s.toString();
  }

  /**
   * Returns the number of nanoseconds of the given duration without throwing or overflowing.
   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing

  public void testPuttingTheSameKeyTwiceThrowsOnBuild() {
    Builder<String, Integer> builder =
        new Builder<String, Integer>()
            .put("one", 1)
            .put("one", 1); // throwing on this line would be even better

    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> builder.build());
    assertThat(expected).hasMessageThat().contains("one");
  }

   * <code>'&#92;u002D'</code>) is recognized as the minus sign.
   *
   * <p>Unlike {@link Long#parseLong(String)}, this method returns {@code null} instead of throwing
   * an exception if parsing fails. Additionally, this method only accepts ASCII digits, and returns
   * {@code null} if non-ASCII digits are present in the string.
   *