} else {
                asc = true;
            }
            if (values.length > 0) {
                if ("term".equals(values[0]) || "key".equals(values[0])) {
                    return BucketOrder.key(asc);
                }
                if ("count".equals(values[0])) {
                    return BucketOrder.count(asc);
                }
            }
        }

    protected int generateLocalKey() {
        // In real implementation, this would get the local key from DiSNI:
        // return memoryRegister.getLkey();
        return keyGenerator.getAndIncrement();
    }

    @Override
    protected int generateRemoteKey() {
        // In real implementation, this would get the remote key from DiSNI:
        // return memoryRegister.getRkey();
        return keyGenerator.getAndIncrement();

     * @throws SmbException if an error occurs checking signing status
     */
    boolean isSigningEnforced() throws SmbException;

    /**
     * Gets the server's encryption key for authentication.
     *
     * @return the encryption key used by the server
     */
    byte[] getServerEncryptionKey();

    /**
     * Gets or creates an SMB session for the given context.
     *
     * @param ctx the CIFS context

        systemProperties.entrySet().stream().forEach(e -> {
            final String key = e.getKey().toString();
            if (!key.startsWith(SAML_PREFIX)) {
                return;
            }
            params.put("onelogin.saml2." + key.substring(SAML_PREFIX.length()), e.getValue());
        });
        return new SettingsBuilder().fromValues(params).build();
    }

    int hashBytes = hashbits / 8;

    byte[] key = new byte[256];
    byte[] hashes = new byte[hashBytes * 256];

    // Hash keys of the form {}, {0}, {0,1}, {0,1,2}... up to N=255,using 256-N as the seed
    for (int i = 0; i < 256; i++) {
      key[i] = (byte) i;
      int seed = 256 - i;
      byte[] hash = hashFunction.hash(Arrays.copyOf(key, i), seed);

        chatApiManager.sendSseEvent(writer, "test", Map.of("key", "value"));

        final String output = stringWriter.toString();
        assertTrue(output.contains("event: test"));
        assertTrue(output.contains("data:"));
        assertTrue(output.contains("\"key\":\"value\""));
    }

    @Test
    public void test_sendSseEvent_session() {

                            "-Porg.gradle.performance.dependencyBuildIds" to dependencyBuildIds,
                            "-PperformanceBaselines" to dependencyBaselines,
                        ).joinToString(" ") { (key, value) -> os.escapeKeyValuePair(key, value) },
                )
            }

            dependencies {
                snapshotDependencies(performanceTestProject.performanceTests) {

    public void testByteArrayFields() {
        // Test encryptionKey
        byte[] key = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
        serverData.encryptionKey = key;
        assertNotNull(serverData.encryptionKey);
        assertArrayEquals(key, serverData.encryptionKey);

        // Test with empty array
        serverData.encryptionKey = new byte[0];

        Map<AccessorKey, ReplacedAccessor> oldMethods = context.getUserData(OLD_REMOVED_ACCESSORS_OF_UPGRADED_PROPERTIES);
        AccessorKey key = AccessorKey.ofOldMethod(jApiMethod);
        return oldMethods.containsKey(key) ? Optional.of(key) : Optional.empty();
    }

        for (int i = 0; i < 150; i++) {
            largeParams.put("key" + i, "value" + i);
        }

        assertNotNull(queryRescorer.evaluate(largeParams));

        // Test with small number of parameters
        Map<String, Object> smallParams = new HashMap<>();
        smallParams.put("key", "value");
        assertNull(queryRescorer.evaluate(smallParams));
    }

    @Test