* implement shutdown and termination behavior.
   *
   * <p>Because of the nature of single-thread execution, the methods {@code scheduleAtFixedRate}
   * and {@code scheduleWithFixedDelay} are not supported by this class and will throw an
   * UnsupportedOperationException.
   *
   * <p>The implementation deviates from the {@code ExecutorService} specification with regards to

        final int start = bufferIndex;

        this.version = SMBUtil.readInt2(buffer, bufferIndex);
        if (this.version != 3 && this.version != 1) {
            throw new RuntimeCIFSException(
                    "Version " + this.version + " referral not supported. Please report this to jcifs at samba dot org.");
        }
        bufferIndex += 2;

     *
     * - _can_ be null without causing a runtime failure (because we don't want the interesting
     *   details of precondition failure to be hidden by an exception we throw about an unexpectedly
     *   null _failure message_)
     *
     * That combination upsets NullPointerTester, which wants any call that passes null for a
     * non-@Nullable parameter to trigger a NullPointerException.

     *
     * - _can_ be null without causing a runtime failure (because we don't want the interesting
     *   details of precondition failure to be hidden by an exception we throw about an unexpectedly
     *   null _failure message_)
     *
     * That combination upsets NullPointerTester, which wants any call that passes null for a
     * non-@Nullable parameter to trigger a NullPointerException.

    void overlapsReturnsTrueThenFalse() throws Exception {
        when(locator.overlaps(other)).thenReturn(true, false);

        assertTrue(locator.overlaps(other));
        assertFalse(locator.overlaps(other));

        verify(locator, times(2)).overlaps(other);
        verifyNoMoreInteractions(locator);
    }

    // Error path: overlaps may throw a CIFSException per signature
    @Test

        // Any accessor that triggers canonicalizePath should throw
        assertThrows(RuntimeCIFSException.class, a::getURLPath);
        assertThrows(RuntimeCIFSException.class, a::getUNCPath);
    }

    @Test
    @DisplayName("Server, port, URL passthrough getters")
    void testServerPortUrl() throws Exception {
        // No context mocks needed for this test

      decodeException.initCause(e);
      throw decodeException;
    }
  }

  /**
   * Returns the unsigned {@code int} value represented by the given decimal string.
   *
   * <p><b>Java 8+ users:</b> use {@link Integer#parseUnsignedInt(String)} instead.
   *
   * @throws NumberFormatException if the string does not contain a valid unsigned {@code int} value

     * @param bufferIndex the starting offset in the buffer
     * @return the number of bytes read
     * @throws SMBProtocolDecodingException if the data cannot be decoded
     */
    protected abstract int readBytesWireFormat(byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException;

    @Override
    public int hashCode() {
        return this.mid;
    }

    @Override

        throw new UnsupportedOperationException("Transport creation needs integration with SmbTransportPool");
    }

    /**
     * Perform channel binding for a channel
     *
     * @param channel channel to bind
     * @throws IOException if binding fails
     */
    public void performChannelBinding(ChannelInfo channel) throws IOException {

 * order that they are added.
 *
 * <p>Exceptions thrown by a listener will be propagated up to the executor. Any exception thrown
 * during {@code Executor.execute} (e.g., a {@code RejectedExecutionException} or an exception
 * thrown by {@linkplain MoreExecutors#directExecutor direct execution}) will be caught and logged.
 *
 * @author Nishant Thakkar