throws InterruptedException {
      lastMethodCalled = "invokeAll";
      assertTaskWrapped(tasks);
      return inline.invokeAll(tasks);
    }

    @Override
    public <T> List<Future<T>> invokeAll(
        Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
        throws InterruptedException {
      assertTaskWrapped(tasks);

import org.codelibs.core.exception.MethodNotStaticRuntimeException;
import org.junit.Test;

/**
 * @author koichik
 *
 */
public class MethodDescTest {

    /**
     * @throws Exception
     */
    @Test
    public void testFoo() throws Exception {
        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final MethodDesc foo = beanDesc.getMethodDesc("foo");
        assertThat(foo, is(notNullValue()));

        // When - should not throw exception
        response.prepare(mockRequest);

        // Then - method completes without error
        assertTrue(true);
    }

    @Test
    @DisplayName("Should verify wire format protocol compliance")
    void testWireFormatProtocolCompliance() throws SMBProtocolDecodingException {

   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final boolean putAll(Multimap<? extends K, ? extends V> multimap) {
    throw new UnsupportedOperationException();
  }

  /**

   * second value, and so on.
   */
  static <K extends @Nullable Object, V extends @Nullable Object> void writeMap(
      Map<K, V> map, ObjectOutputStream stream) throws IOException {
    stream.writeInt(map.size());
    for (Map.Entry<K, V> entry : map.entrySet()) {
      stream.writeObject(entry.getKey());
      stream.writeObject(entry.getValue());
    }
  }

  /**

    @Override
    ResolutionGroup retrieve(
            Artifact artifact, ArtifactRepository localRepository, List<ArtifactRepository> remoteRepositories)
            throws ArtifactMetadataRetrievalException;

    List<ArtifactVersion> retrieveAvailableVersions(MetadataResolutionRequest request)
            throws ArtifactMetadataRetrievalException;

     * @param request {@link ArtifactInstallerRequest}
     * @throws ArtifactInstallerException in case of an error
     * @throws IllegalArgumentException in case {@code request} is {@code null}
     */
    void install(@Nonnull ArtifactInstallerRequest request);

    /**
     * @param session the repository session
     * @param artifact the {@link ProducedArtifact} to install

    }

    @Nested
    @DisplayName("Decoding Tests")
    class DecodingTests {

        @Test
        @DisplayName("Should decode single cipher correctly")
        void testDecodeSingleCipher() throws SMBProtocolDecodingException {
            SMBUtil.writeInt2(1, buffer, 0);
            SMBUtil.writeInt2(EncryptionNegotiateContext.CIPHER_AES128_CCM, buffer, 2);

     * @return established RDMA connection
     * @throws IOException if connection fails
     */
    RdmaConnection connect(String hostname, int port) throws IOException;

    /**
     * Register memory region for RDMA operations
     *
     * @param buffer memory buffer to register
     * @param access access permissions for the memory region
     * @return registered memory region
     * @throws IOException if memory registration fails
     */

        assertThrows(SmbException.class, () -> {
            strictValidator.validatePath("\\share\\file<script>.txt");
        });
    }

    @Test
    public void testTrailingSpace() throws Exception {
        assertThrows(SmbException.class, () -> {
            validator.validatePath("\\share\\file ");
        });
    }

    @Test
    public void testTrailingPeriod() throws Exception {