}

    @Test
    public void testReleaseSendRegion() throws Exception {
        RdmaMemoryRegion region = bufferManager.getSendRegion(1024);
        assertNotNull(region);

        // Release should not throw exception
        assertDoesNotThrow(() -> bufferManager.releaseSendRegion(region));
    }

    @Test
    public void testGetReceiveRegion() throws Exception {

            throws ArtifactMetadataRetrievalException {
        throw new UnsupportedOperationException("Cannot get available versions in this test case");
    }

    @Override
    public List<ArtifactVersion> retrieveAvailableVersionsFromDeploymentRepository(
            Artifact artifact, ArtifactRepository localRepository, ArtifactRepository remoteRepository)
            throws ArtifactMetadataRetrievalException {

  private static final String RETURN_VALUE = "abc";

  private TimeLimiter timeLimiter;

  @Override
  protected void setUp() throws Exception {
    super.setUp();
    timeLimiter = new FakeTimeLimiter();
  }

  public void testCallWithTimeout_propagatesReturnValue() throws Exception {
    String result =
        timeLimiter.callWithTimeout(Callables.returning(RETURN_VALUE), DELAY_MS, MILLISECONDS);

        this.treeHandle.send(this.request, this.response);
        checkStatus();
        final FileEntry n = advance();
        if (n == null) {
            doClose();
        }
        return n;
    }

    /**
     * @throws SmbException
     */
    private void checkStatus() throws SmbException {
        final int status = this.response.getStatus();

      throw new UnsupportedOperationException();
    }

    @Override
    public void shutdown() {
      throw new UnsupportedOperationException();
    }

    @Override
    public List<Runnable> shutdownNow() {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean isShutdown() {
      throw new UnsupportedOperationException();
    }

        @Override
        public void init() throws IOException {
            if (throwExceptionOnInit) {
                throw new IOException("Init failed");
            }
        }

        @Override
        public List<String> convert(String text, String field, String... langs) throws IOException {
            if (throwExceptionOnConvert) {
                throw new IOException("Convert failed");
            }

    }

    @Override
    protected void tearDown(TestInfo testInfo) throws Exception {
        super.tearDown(testInfo);
        // Clear static fields
        clearStaticFields();
    }

    private void clearStaticFields() throws Exception {
        Field runningField = Crawler.class.getDeclaredField("running");
        runningField.setAccessible(true);

    public byte[] compress(byte[] data, int algorithm) throws CIFSException {
        if (data == null) {
            throw new CIFSException("Data cannot be null");
        }
        return compress(data, 0, data.length, algorithm);
    }

    @Override
    public byte[] compress(byte[] data, int offset, int length, int algorithm) throws CIFSException {
        if (data == null) {
            throw new CIFSException("Data cannot be null");
        }

                }
            } else {
                throw new IllegalStateException("unexpected task " + task);
            }
        }
        return mojoExecutions;
    }

    private Map<String, List<MojoExecution>> calculateLifecycleMappings(
            MavenSession session, MavenProject project, String lifecyclePhase)

   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final int setCount(E element, int count) {
    throw new UnsupportedOperationException();
  }

  /**