public void testSetFuture_stackOverflow() {
    SettableFuture<String> orig = SettableFuture.create();
    SettableFuture<String> prev = orig;
    for (int i = 0; i < 100000; i++) {
      SettableFuture<String> curr = SettableFuture.create();
      prev.setFuture(curr);
      prev = curr;
    }
    // prev represents the 'innermost' future
    prev.set("done");

```properties
# Lease configuration
jcifs.smb.client.useLeases=true
jcifs.smb.client.leaseTimeout=30000

# Persistent handles
jcifs.smb.client.usePersistentHandles=true
jcifs.smb.client.durableTimeout=120000

# Multi-channel
jcifs.smb.client.useMultiChannel=true
jcifs.smb.client.maxChannels=4
jcifs.smb.client.channelBindingPolicy=required

# Directory leasing
jcifs.smb.client.useDirectoryLeasing=true

        void testRelativeConstructorWithSid() throws Exception {
            // Arrange
            SID dom = new SID("S-1-5-21");
            SID rel = new SID("S-1-2-200-300"); // two subauthorities appended

            // Act
            SID combined = new SID(dom, rel);

            // Assert
            assertEquals("S-1-5-21-200-300", combined.toString());
        }

      checkConsistentHashCorrectness(r.nextLong());
    }
  }

  private void checkConsistentHashCorrectness(long hashCode) {
    int last = 0;
    for (int shards = 1; shards <= 100000; shards++) {
      int b = Hashing.consistentHash(hashCode, shards);
      if (b != last) {
        assertEquals(shards - 1, b);
        last = b;
      }
    }
  }

        assertTrue(exceptions.isEmpty(), "No exceptions should occur with thread-safe collections: " + exceptions);
        assertEquals(threadCount * operationsPerThread, treeOperations.get());
        assertTrue(avgOpTimeNs < 100000, "Tree operations should be reasonable with CopyOnWriteArrayList");

        session.release();
    }

    /**
     * Performance regression test for all critical fixes
     */
    @Test

        assertTrue(populatedString.contains("partialResults=false"));
        assertTrue(populatedString.contains("queryTime=500"));
        assertTrue(populatedString.contains("requestedTime=1000000"));
    }

    public void test_complexScenario() {
        // Simulate a typical search result scenario
        // Page 2 of search results with 10 items per page
        searchRenderData.setPageSize(10);

     * labels.facet_filetype_title:labels.facet_filetype_html=filetype:html	labels.facet_filetype_word=filetype:word	labels.facet_filetype_excel=filetype:excel	lab...

          double z = aa.updateAndGet(i, value -> value - y);
          assertBitEquals(x - y, z);
          assertBitEquals(x - y, aa.get(i));
        }
      }
    }
  }

  static final long COUNTDOWN = 100000;

  class Counter extends CheckedRunnable {
    final AtomicDoubleArray aa;
    volatile long counts;

    Counter(AtomicDoubleArray a) {
      aa = a;
    }

    @Override

labels.facet_contentLength_10kto100k=content_length:[10000 TO 99999]\t\
labels.facet_contentLength_100kto500k=content_length:[100000 TO 499999]\t\
labels.facet_contentLength_500kto1m=content_length:[500000 TO 999999]\t\
labels.facet_contentLength_1m=content_length:[1000000 TO *]\n\
labels.facet_filetype_title:\
labels.facet_filetype_html=filetype:html\t\
labels.facet_filetype_word=filetype:word\t\

      checkConsistentHashCorrectness(r.nextLong());
    }
  }

  private void checkConsistentHashCorrectness(long hashCode) {
    int last = 0;
    for (int shards = 1; shards <= 100000; shards++) {
      int b = Hashing.consistentHash(hashCode, shards);
      if (b != last) {
        assertEquals(shards - 1, b);
        last = b;
      }
    }
  }