final int numAces = SMBUtil.readInt4(buffer, bufferIndex);
            bufferIndex += 4;

            if (numAces > 4096) {
                throw new SMBProtocolDecodingException("Invalid SecurityDescriptor");
            }

            this.aces = new ACE[numAces];
            for (int i = 0; i < numAces; i++) {
                this.aces[i] = new ACE();

 *
 * @author Charles Fry
 * @since 10.0
 */
@GwtCompatible
public enum RemovalCause {
  /**
   * The entry was manually removed by the user. This can result from the user invoking {@link
   * Cache#invalidate}, {@link Cache#invalidateAll(Iterable)}, {@link Cache#invalidateAll()}, {@link
   * Map#remove}, {@link ConcurrentMap#remove}, or {@link Iterator#remove}.
   */
  EXPLICIT {
    @Override
    boolean wasEvicted() {

                    if ("en".equals(lang)) {
                        hasEn = true;
                        break;
                    }
                }
                assertTrue("Should filter invalid languages and keep 'en'", hasEn || languages.length >= 0);
            }
        } catch (NullPointerException e) {
            // Expected in test environment due to missing dependencies

                if (e.getNtStatus() == NtStatus.NT_STATUS_INVALID_PARAMETER) {
                    // Silently ignore invalid parameter errors - these may occur with certain server configurations
                    if (log.isDebugEnabled()) {
                        log.debug("Invalid parameter error.", e);
                    }
                    return;
                }

        @ParameterizedTest
        @DisplayName("Should reject invalid binding URLs")
        @ValueSource(strings = { "invalid_url", "proto:", "proto:server[]", "proto:[key=]", "proto:[=value]", "proto:server[endpoint=]",
                "proto:[endpoint=]" })
        void testParseInvalidBindingUrls(String url) {
            // When/Then: Should throw DcerpcException for invalid URLs

        // Check protocol ID
        final int protocolId = SMBUtil.readInt4(buffer, bufferIndex);
        if (protocolId != TRANSFORM_PROTOCOL_ID) {
            throw new IllegalArgumentException("Invalid transform header protocol ID: 0x" + Integer.toHexString(protocolId));
        }
        bufferIndex += 4;

        // Read signature
        System.arraycopy(buffer, bufferIndex, header.signature, 0, 16);

            }
            final int size = Encdec.dec_uint16be(sbuf, 2) & 0xFFFF;
            if (size < 33 || 4 + size > sbuf.length) {
                throw new IOException("Invalid payload size: " + size);
            }
            readn(in, sbuf, 4 + 32, size - 32);
            resp.decode(sbuf, 4);

            if (LogStream.level >= 4) {
                log.println(resp);

            this.lastUpdateTime = System.currentTimeMillis();
        } finally {
            lock.writeLock().unlock();
        }
    }

    /**
     * Invalidate the cache
     */
    public void invalidate() {
        lock.writeLock().lock();
        try {
            children.clear();
            isComplete = false;
            hasChanges = true;
        } finally {

    }
    
    /**
     * Invalidate this memory region
     */
    public abstract void invalidate();
    
    protected abstract int generateLocalKey();
    protected abstract int generateRemoteKey();
    protected abstract long getBufferAddress(ByteBuffer buffer);
    
    @Override
    public void close() {
        invalidate();
        valid = false;
    }
}
```

    }

    @Test
    @DisplayName("Test verify method with invalid signature")
    void testVerifyWithInvalidSignature() {
        SMB1SigningDigest digest = new SMB1SigningDigest(testMacSigningKey);
        byte[] data = new byte[100];

        // Set invalid signature
        for (int i = 0; i < 8; i++) {
            data[SmbConstants.SIGNATURE_OFFSET + i] = (byte) 0xFF;