metaDataPoolPut(entry.metadata)
			m.o[i].metadata = nil
		}
	}
	m.o = m.o[idx:]
}

// mergeEntryChannels will merge entries from in and return them sorted on out.
// To signify no more results are on an input channel, close it.
// The output channel will be closed when all inputs are emptied.
// If file names are equal, compareMeta is called to select which one to choose.
// The entry not chosen will be discarded.

   * each call to this method may claim and hold a thread for an arbitrary length of time. Use of
   * bounded executors or other executors that may fail to execute a task promptly may result in
   * deadlocks.
   *
   * <p>Prefer to create {@code ListenableFuture} instances with {@link SettableFuture}, {@link
   * MoreExecutors#listeningDecorator( java.util.concurrent.ExecutorService)}, {@link

			} else {
				m[xhttp.AmzChecksumType] = xhttp.AmzChecksumTypeComposite
			}

			w := httptest.NewRecorder()
			AddChecksumHeader(w, m)
			gotChksm, err := GetContentChecksum(w.Result().Header)
			if tt.wantErr {
				if err == nil {
					t.Fatalf("Expected error for %s, got none", tt.name)
				}
				return
			}
			if err != nil {

        // Given
        ServerMessageBlock2 nextMessage = mock(ServerMessageBlock2.class);

        // When
        boolean result = request.chain(nextMessage);

        // Then
        verify(nextMessage).setSessionId(Smb2Constants.UNSPECIFIED_SESSIONID);
        assertTrue(result); // Assuming superclass chain returns true
    }

    @Test
    @DisplayName("Should calculate correct message size with token")

        assertNotNull(decrypted);
        // With dummy data, we can't verify the content, just that it decrypts without error
        // and returns a result of the expected size.
        assertEquals(data.length - 24, decrypted.length);
    }

    /**
     * Test decrypt with an unsupported encryption type.
     */
    @Test

 *
 * <p>
 *   The Deferred class uses a CountDownLatch to allow you to wait for the computation to complete.
 *   The resolve and reject methods decrement the CountDownLatch, allowing the getResponse method
 *   to return the result of the computation.
 * </p>
 *
 * @param <RESPONSE> The type of the response.
 */
public class Deferred<RESPONSE extends Response> {
    /**
     * Constructs a new Deferred object.
     */

   * be included, and it's much easier to implement the interpretation that they not be. Finally, a
   * call to {@code shutdown} or {@code shutdownNow} may result in concurrent calls to {@code
   * invokeAll/invokeAny} throwing RejectedExecutionException, although a subset of the tasks may
   * already have been executed.
   *

 * of a {@code SortedSetMultimap} in a way that affects its {@link Object#equals} behavior (or its
 * position in the order of the values). Undefined behavior and bugs will result.
 *
 * <p>See the Guava User Guide article on <a href=
 * "https://github.com/google/guava/wiki/NewCollectionTypesExplained#multimap">{@code Multimap}</a>.
 *
 * @author Jared Levy
 * @since 2.0
 */
@GwtCompatible

         *
         * @throws NullPointerException if passed in buffer is {@code null}.
         */
        void update(@Nonnull ByteBuffer input);

        /**
         * Returns the algorithm end result as string, never {@code null}. After invoking this method, this instance should
         * be discarded and not reused. For new checksum calculation you have to get new instance.
         */
        @Nonnull

			secretKey:          credentials.SecretKey,
			expectedRespStatus: http.StatusBadRequest,
		},
		// Test case - 8.
		// non-existent bucket is used.
		// writing BucketPolicy should fail.
		// should result in 404 StatusNotFound
		{
			bucketName:         "non-existent-bucket",
			bucketPolicyReader: bytes.NewReader(fmt.Appendf(nil, bucketPolicyTemplate, "non-existent-bucket", "non-existent-bucket")),