// Test with offset pointing outside array bounds (should throw ArrayIndexOutOfBoundsException)
        buffer.putShort(0, (short) 1);
        buffer.putShort(2, (short) 1);
        buffer.putInt(4, data.length + 1); // Invalid offset
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> NtlmMessage.readSecurityBuffer(data, 0),
                "Should throw ArrayIndexOutOfBoundsException for invalid offset.");
    }

            this.manager = manager;
        }

        public T get() {
            if (closed) {
                throw new IllegalStateException("Resource has been closed: " + resourceId);
            }
            return resource;
        }

        @Override
        public void close() throws Exception {
            if (closed) {
                return;
            }

            try {

        assertTrue(exception instanceof Throwable);
    }

    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        String expectedType = "OAuth";
        String expectedMessage = "OAuth token is invalid";

        try {
            throw new InvalidAccessTokenException(expectedType, expectedMessage);
        } catch (InvalidAccessTokenException e) {

    return copy(writeTimeoutMillis = checkDuration("writeTimeout", timeout.toLong(), unit))
  }

  override fun call(): Call = call

  override fun request(): Request = request

  @Throws(IOException::class)
  override fun proceed(request: Request): Response {
    check(index < interceptors.size)

    calls++

    if (exchange != null) {

   * Object#toString}.
   */
  NON_STANDARD_TOSTRING,

  /**
   * Indicates that the constructor or factory method of a collection, usually an immutable set,
   * throws an {@link IllegalArgumentException} when presented with duplicate elements instead of
   * collapsing them to a single element or including duplicate instances in the collection.
   */
  REJECTS_DUPLICATES_AT_CREATION,

  Object writeReplace() {
    return new EnumSerializedForm<E>(delegate);
  }

  @J2ktIncompatible // serialization
  private void readObject(ObjectInputStream stream) throws InvalidObjectException {
    throw new InvalidObjectException("Use SerializedForm");
  }

  /*
   * This class is used to serialize ImmutableEnumSet instances.
   */
  @J2ktIncompatible // serialization

    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.NtlmPasswordAuthenticator#getAnsiHash(jcifs.CIFSContext, byte[])
     */
    @Override
    public byte[] getAnsiHash(final CIFSContext tc, final byte[] chlng) throws GeneralSecurityException {
        if (this.hashesExternal) {
            return this.ansiHash;
        }
        return super.getAnsiHash(tc, chlng);
    }

    /**
     * {@inheritDoc}
     *

     */
    @Override
    protected int readBytesWireFormat(final byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);

        if (structureSize != 9) {
            throw new SMBProtocolDecodingException("Expected structureSize = 9");
        }

    private FessUserLocaleProcessProvider provider;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        provider = new FessUserLocaleProcessProvider();
    }

    @Override
    public void tearDown() throws Exception {
        ComponentUtil.setFessConfig(null);
        super.tearDown();
    }

    // Test isAcceptCookieLocale method

    return this;
  }

  /**
   * Specifies the expected number of nodes in the graph.
   *
   * @throws IllegalArgumentException if {@code expectedNodeCount} is negative
   */
  @CanIgnoreReturnValue
  public ValueGraphBuilder<N, V> expectedNodeCount(int expectedNodeCount) {
    this.expectedNodeCount = Optional.of(checkNonNegative(expectedNodeCount));
    return this;
  }

  /**