}

  public void testDefaultExecutorIsShutdownWhenServiceFails() throws Exception {
    AtomicReference<ScheduledExecutorService> executor = Atomics.newReference();
    AbstractScheduledService service =
        new AbstractScheduledService() {
          @Override
          protected void startUp() throws Exception {
            throw new Exception("Failed");
          }

          @Override

     * @param fieldName the field name for error reporting
     * @throws IllegalArgumentException if size is invalid
     */
    public static void validateBufferSize(int size, int maxSize, String fieldName) {
        if (size < 0) {
            throw new IllegalArgumentException(fieldName + " size cannot be negative: " + size);
        }
        if (size > maxSize) {

    assertStillOpen(closeable1);
  }

  public void testFrom_failedInput() throws Exception {
    assertFinallyFailsWithException(failedClosingFuture());
  }

  public void testFrom_cancelledInput() throws Exception {
    assertBecomesCanceled(ClosingFuture.from(immediateCancelledFuture()));
  }

  public void testEventuallyClosing() throws Exception {
    ClosingFuture<String> closingFuture =

     * @throws PACDecodingException if the token cannot be decoded
     */
    public KerberosApRequest(byte[] token, KerberosKey[] keys) throws PACDecodingException {
        this(parseSequence(token), keys);
    }

    private static ASN1Sequence parseSequence(byte[] token) throws PACDecodingException {
        if (token.length <= 0) {
            throw new PACDecodingException("Empty kerberos ApReq");

        protected long makeKey(Request request) throws IOException {
            return nextKey++;
        }

        @Override
        protected Long peekKey() throws IOException {
            if (recvException != null) {
                throw recvException;
            }
            return peekedKey;
        }

        @Override
        protected void doSend(Request request) throws IOException {

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

  /**

     * Establish RDMA connection
     */
    public abstract void connect() throws IOException;
    
    /**
     * Send data using RDMA
     */
    public abstract void send(ByteBuffer data, RdmaMemoryRegion region) throws IOException;
    
    /**
     * Receive data using RDMA  
     */
    public abstract ByteBuffer receive(int timeout) throws IOException;
    
    /**
     * Perform RDMA read operation

            throw SmbException.wrap(e);
        }
    }

    @Override
    public final boolean readBoolean() throws SmbException {
        if (read(this.tmp, 0, 1) < 0) {
            throw new SmbEndOfFileException();
        }
        return this.tmp[0] != (byte) 0x00;
    }

    @Override
    public final byte readByte() throws SmbException {

    final List<State> transitionStates = new ArrayList<>();

    @Override
    protected void startUp() throws Exception {
      assertEquals(0, startUpCalled);
      assertEquals(0, shutDownCalled);
      startUpCalled++;
      assertEquals(State.STARTING, state());
    }

    @Override
    protected void shutDown() throws Exception {
      assertEquals(1, startUpCalled);
      assertEquals(0, shutDownCalled);

     * @param wagon
     * @param repository
     *
     * @throws ConnectionException
     * @throws AuthenticationException
     */
    private void connectWagon(Wagon wagon, ArtifactRepository repository)
            throws ConnectionException, AuthenticationException {
        // MNG-5509
        // See org.eclipse.aether.connector.wagon.WagonRepositoryConnector.connectWagon(Wagon)
        if (legacySupport.getRepositorySession() != null) {