package jcifs.smb.compression;

import jcifs.CIFSException;

/**
 * Interface for SMB3 compression services.
 *
 * Provides compression and decompression functionality for SMB3 protocol
 * data transfers with support for multiple compression algorithms.
 */
public interface CompressionService {

    /**
     * Compression algorithm constants matching SMB3 specification.
     */
    public static final int COMPRESSION_NONE = 0x0;

  private static BigInteger oldSlowFactorial(int n) {
    if (n <= 20) {
      return BigInteger.valueOf(LongMath.factorial(n));
    } else {
      int k = 20;
      return BigInteger.valueOf(LongMath.factorial(k)).multiply(oldSlowFactorial(k, n));
    }
  }

  /** Returns the product of {@code n1} exclusive through {@code n2} inclusive. */
  @SuppressWarnings("UseCorrectAssertInTests") // TODO(b/345814817): Remove or convert assertion.

        assertNotNull(request);
    }

    @Test
    @DisplayName("Test size calculation with multiple dialects")
    void testSizeWithMultipleDialects() {
        ValidateNegotiateInfoRequest request =
                new ValidateNegotiateInfoRequest(DEFAULT_CAPABILITIES, defaultClientGuid, DEFAULT_SECURITY_MODE, defaultDialects);

        // Verify the values match
        assertEquals(original.toString(), decoded.toString());
    }

    /**
     * Test multiple FileInformation implementations can coexist
     */
    @Test
    @DisplayName("Test multiple FileInformation implementations")
    void testMultipleFileInformationImplementations() {
        // Create different mock implementations

        verify(tree).connectLogon(ctx);
    }

    @Test
    @DisplayName("Should sort addresses by fail count and failover")
    void testFailoverWithFailCounts() throws Exception {
        // Given: Multiple addresses with different fail counts
        Address addr1 = mock(Address.class);
        when(addr1.getHostAddress()).thenReturn("10.0.0.1");

        Address addr2 = mock(Address.class);

      private val useCompression: Boolean = true,
      private val out: Buffer,
    ) {
      /**
       * In the scenario where the dynamic table size changes multiple times between transmission of
       * header blocks, we need to keep track of the smallest value in that interval.
       */
      private var smallestHeaderTableSizeSetting = Integer.MAX_VALUE

        // Then
        assertNotNull(result);
        assertEquals(Integer.MAX_VALUE, result.intValue());
        verify(request, times(1)).getOverrideTimeout();
    }

    @Test
    @DisplayName("Test multiple method invocations")
    void testMultipleMethodInvocations() {
        // Given
        when(request.isResponseAsync()).thenReturn(true);
        when(request.size()).thenReturn(100);

     * found in the cache. This method should be called by the loading thread, as well as by threads
     * blocking on the load. Multiple concurrent calls to {@link Cache} lookup methods with the same
     * key on an absent value should result in a single call to either {@code recordLoadSuccess} or
     * {@code recordLoadException} and multiple calls to this method, despite all being served by
     * the results of a single load operation.
     *

                .forEach(s -> buf.append(s));
        log(buf);
    }

    /**
     * Increments the thread reference count for the specified crawler object.
     * Used when the same object is being processed on multiple threads.
     *
     * @param keyObj the crawler object running on an additional thread
     */
    public void runOnThread(final Object keyObj) {
        getCacheKey(keyObj).ifPresent(key -> {
            try {

   * the factory that created it.
   *
   * <p>Note, however, that although multiple locks can be created for a given Enum value, whether
   * it be through separate factory instances or through multiple calls to the same factory,
   * attempting to acquire multiple locks with the same Enum value (within the same thread) will