return reader.read() == -1;
    } catch (Throwable e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }
  }

  /**
   * Concatenates multiple {@link CharSource} instances into a single source. Streams returned from
   * the source will contain the concatenated data from the streams of the underlying sources.
   *

            assertTrue(e.getCause() instanceof InterruptedException);
        }
    }

    public void test_concurrent_initialization() throws Exception {
        // Test that compareAndSet prevents multiple initializations
        final FileSystemClient client = new FileSystemClient();
        final int threadCount = 10;
        final Thread[] threads = new Thread[threadCount];

  /**
   * Replaces the existing container under test with a new container. This is useful when a single
   * test method needs to create multiple containers while retaining the ability to use {@link
   * #expectContents(Object[]) expectContents(E...)} and other convenience methods. The creation of
   * multiple containers in a single method is discouraged in most cases, but it is vital to the
   * iterator tests.
   *

        assertEquals("  rule with spaces  ", testRule.getRuleId());
    }

    /**
     * Test multiple registrations of same rule
     */
    public void test_multipleRegistrations() {
        testRule.setRuleId("multiRegRule");

        // Register multiple times
        testRule.register(0);
        testRule.register(0);
        testRule.register(1);

            transportPool.removeTransport(null);

            // Then
            verify(transportPool).removeTransport(null);
        }

        @Test
        @DisplayName("Should remove multiple transports")
        void testRemoveMultipleTransports() {
            // Given
            SmbTransport transport2 = mock(SmbTransport.class);
            doNothing().when(transportPool).removeTransport(any());

        // Newline characters
        testTransformer.setName("name\nwith\nnewlines");
        assertEquals("name\nwith\nnewlines", testTransformer.getName());
    }

    /**
     * Test multiple name changes
     */
    public void test_multipleNameChanges() {
        String[] names = { "first", "second", "third", "fourth", "fifth" };

        for (String name : names) {

 */
package org.codelibs.fess.entity;

import java.util.Arrays;

/**
 * Entity class representing a request parameter with a name and associated values.
 * This class encapsulates HTTP request parameters that can have multiple values,
 * such as query parameters, form parameters, or other request-related data.
 *
 * <p>This class is immutable and thread-safe. Once created, the parameter name
 * and values cannot be modified.</p>
 *
 */

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;

        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