*   <li>If a {@code Throwable} is thrown in the try block, no exceptions that occur when attempting
 *       to close resources will be thrown from the finally block. The throwable from the try block
 *       will be thrown.
 *   <li>If no exceptions or errors were thrown in the try block, the <i>first</i> exception thrown
 *       by an attempt to close a resource will be thrown.

    List<BlockDoc> getExtensionBlocks() {
        List<BlockDoc> blocks = []
        mixinClasses.each { mixin ->
            mixin.classBlocks.each { block ->
                blocks << block.forClass(targetClass)
            }
        }
        extraBlocks.each { block->
            blocks << block.forClass(targetClass)
        }
        return blocks.sort { it.name }
    }

        MethodMetaData tooManyParams = method('block', classMetaData, paramTypes: ['String', 'boolean'])
        MethodMetaData notAClosure = method('block', classMetaData, paramTypes: ['String'])
        MethodMetaData noBlockProperty = method('notBlock', classMetaData, paramTypes: [Closure.class.name])
        _ * classMetaData.findProperty('block') >> blockProperty

            data = new byte[128];
            Arrays.fill(data, (byte) 0x00);

            // Set up mock messages
            request = mock(CommonServerMessageBlock.class);
            response = mock(CommonServerMessageBlock.class);
        }

        @Test
        @DisplayName("Should sign data correctly with zero signature field")

If you use a `try` block in a dependency with `yield`, you'll receive any exception that was thrown when using the dependency.

For example, if some code at some point in the middle, in another dependency or in a *path operation*, made a database transaction "rollback" or created any other exception, you would receive the exception in your dependency.

import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.CIFSException;

@ExtendWith(MockitoExtension.class)
class SmbPipeOutputStreamTest {

    @Mock
    SmbPipeHandleImpl handle;

    @Mock
    SmbTreeHandleImpl tree;

    @Mock
    SmbNamedPipe pipe;

    @Mock
    SmbFileHandleImpl fileHandle;

import static org.junit.jupiter.api.Assertions.assertNotNull;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import jcifs.dcerpc.rpc.policy_handle;

class MsrpcSamrCloseHandleTest {

    @Mock
    private policy_handle mockPolicyHandle;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    }

    /// Encrypt a block of bytes.
    /**
     * Encrypts an 8-byte block using DES
     * @param clearText the 8-byte plaintext block
     * @param cipherText the output 8-byte ciphertext block
     */
    public void encrypt(final byte[] clearText, final byte[] cipherText) {
        encrypt(clearText, 0, cipherText, 0);
    }

    /// Decrypt a block of bytes.
    /**

 */
@ExtendWith(MockitoExtension.class)
class SmbTreeInternalTest {

    @Mock
    private SmbTreeInternal tree;

    @Mock
    private CIFSContext context;

    @Mock
    private Request<CommonServerMessageBlockResponse> request;

    @Mock
    private CommonServerMessageBlockResponse response;

    @Test

    @BeforeEach
    public void setUp() {
        mockContext = Mockito.mock(CIFSContext.class);
        mockTransport = Mockito.mock(SmbTransportImpl.class);
        mockConfig = Mockito.mock(Configuration.class);
        mockCredentials = Mockito.mock(Credentials.class);
        mockCredentialsInternal = Mockito.mock(CredentialsInternal.class);

        Mockito.when(mockContext.getConfig()).thenReturn(mockConfig);