if (lowerBound != null) {
            int comparison = lowerBound.compareTo(version);

            if ((comparison == 0) && !lowerBoundInclusive) {
                return false;
            }
            if (comparison > 0) {
                return false;
            }
        }
        if (upperBound != null) {
            int comparison = upperBound.compareTo(version);

    val retryOnConnectionFailure: Boolean = client.retryOnConnectionFailure()
    val callTimeoutMillis: Int = client.callTimeoutMillis()
    val connectTimeoutMillis: Int = client.connectTimeoutMillis()
    val readTimeoutMillis: Int = client.readTimeoutMillis()
    val writeTimeoutMillis: Int = client.writeTimeoutMillis()
    val pingIntervalMillis: Int = client.pingIntervalMillis()
  }

  @Test @Disabled
  fun pushPromise() {

    private int lineNumber;

    private int columnNumber;

    public SettingsConfigurationException(String message) {
        super(message);
    }

    public SettingsConfigurationException(String message, Throwable cause) {
        super(message, cause);
    }

    public SettingsConfigurationException(String message, Throwable cause, int lineNumber, int columnNumber) {
        super(

            } else {
                return 1;
            }
        }

        int g = compareStrings(md.groupId, vmd.groupId);

        if (g == 0) {
            int a = compareStrings(md.artifactId, vmd.artifactId);
            if (a == 0) {
                if (compareVersion) {
                    int v = compareStrings(md.version, vmd.version);
                    if (v == 0) {

    public static final int SEQUENCE_CHECKING = 0x10;
    /**
     * Context flag for anonymity capability
     */
    public static final int ANONYMITY = 0x08;
    /**
     * Context flag for confidentiality (encryption) capability
     */
    public static final int CONFIDENTIALITY = 0x04;
    /**
     * Context flag for integrity (signing) capability
     */
    public static final int INTEGRITY = 0x02;

        // When - Multiple threads accessing trees concurrently
        for (int t = 0; t < threadCount; t++) {
            final int threadId = t;
            executor.submit(() -> {
                try {
                    startLatch.await(); // Wait for all threads to be ready

                    for (int i = 0; i < opsPerThread; i++) {

    void testWriteParametersWireFormatNetServerEnum2() throws Exception {
        String domain = "TESTDOMAIN";
        int serverTypes = NetServerEnum2.SV_TYPE_ALL;
        netServerEnum2 = new NetServerEnum2(realConfig, domain, serverTypes);

        byte[] dst = new byte[1024];
        int dstIndex = 0;

        int bytesWritten = netServerEnum2.writeParametersWireFormat(dst, dstIndex);

        // Verify bytes written

    private static final int FILE_ACTION_MODIFIED = 0x00000003;
    private static final int FILE_ACTION_RENAMED_OLD_NAME = 0x00000004;
    private static final int FILE_ACTION_RENAMED_NEW_NAME = 0x00000005;
    
    private static final int FILE_NOTIFY_CHANGE_FILE_NAME = 0x00000001;
    private static final int FILE_NOTIFY_CHANGE_DIR_NAME = 0x00000002;
    private static final int FILE_NOTIFY_CHANGE_ATTRIBUTES = 0x00000004;

   *     such index exists.
   */
  public static int indexOf(char[] array, char target) {
    return indexOf(array, target, 0, array.length);
  }

  // TODO(kevinb): consider making this public
  private static int indexOf(char[] array, char target, int start, int end) {
    for (int i = start; i < end; i++) {
      if (array[i] == target) {
        return i;
      }
    }

        // Test size calculation
        int size = request.size();
        int expectedRawSize = Smb2Constants.SMB2_HEADER_LENGTH + 32 + 64;
        int expectedSize = (expectedRawSize + 7) & ~7;
        assertEquals(expectedSize, size);

        // Test wire format writing
        byte[] buffer = new byte[512];
        int bytesWritten = request.writeBytesWireFormat(buffer, 64);