// NOTE: if timeout < 0, remainingNanos will be < 0 and we will fall into the while(true) loop
    // at the bottom and throw a timeoutexception.
    long timeoutNanos = unit.toNanos(timeout); // we rely on the implicit null check on unit.
    long remainingNanos = timeoutNanos;
    if (Thread.interrupted()) {
      throw new InterruptedException();
    }
    @RetainedLocalRef Object localValue = valueField;

            this.rpcHandle.bind();
            this.connected = true;

            log.debug("Connected to witness service at {}", serverAddress.getHostAddress());
        } catch (Exception e) {
            throw new IOException("Failed to connect to witness service", e);
        }
    }

    /**
     * Builds the RPC URL for the witness service.
     *
     * @param serverAddress the server address

    private boolean startUpCalled = false;

    @Override
    protected void startUp() {
      startUpCalled = true;
      throw new UnsupportedOperationException("kaboom!");
    }

    @Override
    protected void run() {
      throw new AssertionError("run() should not be called");
    }

    @Override
    protected Executor executor() {
      return exceptionCatchingExecutor;

    assertEquals(
        "computeIfAbsent(present, function) should return existing value",
        v0(),
        getMap()
            .computeIfAbsent(
                k0(),
                k -> {
                  throw new AssertionFailedError();
                }));
    expectUnchanged();
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfAbsent_functionReturnsNullNotInserted() {
    assertNull(

    // NOTE: if timeout < 0, remainingNanos will be < 0 and we will fall into the while(true) loop
    // at the bottom and throw a timeoutexception.
    long timeoutNanos = unit.toNanos(timeout); // we rely on the implicit null check on unit.
    long remainingNanos = timeoutNanos;
    if (Thread.interrupted()) {
      throw new InterruptedException();
    }
    @RetainedLocalRef Object localValue = valueField;

            decodeCallCount++;
            if (throwOnDecode) {
                throw new SMBProtocolDecodingException("Test decode error");
            }
            if (buffer == null) {
                throw new SMBProtocolDecodingException("Buffer cannot be null");
            }
            if (bufferIndex < 0 || len < 0) {
                throw new SMBProtocolDecodingException("Invalid buffer parameters");
            }

    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the {@code RangeMap} unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final void remove(Range<K> range) {

            }
        } catch (final CrawlerSystemException e) {
            CloseableUtil.closeQuietly(responseData);
            throw e;
        } catch (final Exception e) {
            CloseableUtil.closeQuietly(responseData);
            throw new CrawlingAccessException("Could not access " + uri, e);
        }

        return responseData;
    }

    /**

            SerializableTester.reserializeAndAssert(instance);
          } catch (Exception e) { // sneaky checked exception
            throw new AssertionError(
                "Serialization failed on return value of " + factory, e.getCause());
          } catch (AssertionFailedError e) {
            throw new AssertionError(
                "Return value of " + factory + " reserialized to an unequal value", e);
          }
        }

     * @throws SmbException if an error occurs
     */
    public static SmbFile[] listFilesWithLeasing(SmbFile smbFile) throws SmbException {
        if (!smbFile.isDirectory()) {
            throw new SmbException("Not a directory: " + smbFile.getPath());
        }

        try (SmbTreeHandleImpl th = smbFile.ensureTreeConnected()) {
            // Check if we can use directory leasing