return;
      }

      oldRunCount = workerRunCount;

      // If the worker is not yet running, the delegate Executor might reject our attempt to start
      // it. To preserve FIFO order and failure atomicity of rejected execution when the same
      // Runnable is executed more than once, allocate a wrapper that we know is safe to remove by
      // object identity.

        assertTrue(ex.getMessage().contains("directory must end with '/'"));
        verify(tree, times(1)).acquire();
        verify(tree, times(1)).release(); // closed after failure
    }

    @Test
    @DisplayName("open(): invalid UNC without trailing backslash throws SmbException")
    void invalidUncThrows() throws Exception {
        // Override the default setup for this specific test

        verify(transport).ensureConnected();
    }

    // Error case: ensureConnected throws IOException
    @Test
    @DisplayName("ensureConnected throws IOException on failure")
    void ensureConnected_throwsIOException() throws Exception {
        doThrow(new java.io.IOException("connect failed")).when(transport).ensureConnected();

            SmbFile dest = mock(SmbFile.class);
            CIFSContext ctx = ctxWithIgnore(false);
            when(src.getContext()).thenReturn(ctx);

            // Force failure before any stream construction
            when(src.openUnshared(anyInt(), anyInt(), anyInt(), anyInt(), anyInt())).thenThrow(new SmbException("boom"));

## Une application avec des callbacks { #an-app-with-callbacks }

Voyons tout cela avec un exemple.

Imaginez que vous développiez une application qui permet de créer des factures.

Ces factures auront un `id`, un `title` (facultatif), un `customer` et un `total`.

L’utilisateur de votre API (une personne développeuse externe) créera une facture dans votre API avec une requête POST.

    }

    /**
     * Deletes a key match setting by ID.
     *
     * @param id the ID of the key match setting to delete
     * @return JSON response indicating success or failure
     */
    // DELETE /api/admin/keymatch/setting/{id}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String id) {
        keyMatchService.getKeyMatch(id).ifPresent(entity -> {

     */
    @Override
    public boolean verifySignature(final byte[] buffer, final int i, final int size) {
        // observed too that signatures on error responses are sometimes wrong??
        // Looks like the failure case also is just reflecting back the signature we sent

        // with SMB3's negotiation validation it's no longer possible to ignore this (on the validation response)

	defer m.mu.Unlock()
	for bucket, b := range m.buckets {
		b.deleteAll()
		delete(m.buckets, bucket)
	}
}

// checkMetacacheState should be used if data is not updating.
// Should only be called if a failure occurred.
func (o listPathOptions) checkMetacacheState(ctx context.Context, rpc *peerRESTClient) error {
	// We operate on a copy...
	o.Create = false
	c, err := rpc.GetMetacacheListing(ctx, o)
	if err != nil {

        });
        // Each defined distribution archive is linked to a subproject.
        // A distribution archive definition not matching a sub project will result in build failure.
        container.whenObjectAdded(distributionArchive -> {
            var subProjectName = archiveToSubprojectName(distributionArchive.getName());
            project.project(subProjectName, sub -> {

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class CollectionRetainAllTester<E> extends AbstractCollectionTester<E> {

  /** A collection of elements to retain, along with a description for use in failure messages. */
  private final class Target {
    private final Collection<E> toRetain;
    private final String description;

    private Target(Collection<E> toRetain, String description) {
      this.toRetain = toRetain;