this.data = data;
        this.dataOffset = offset;
        this.dataLength = length;
    }

    /**
     * Sets the number of bytes remaining to be written in a sequence of write operations.
     *
     * @param remainingBytes the remainingBytes to set
     */
    public void setRemainingBytes(final int remainingBytes) {
        this.remainingBytes = remainingBytes;
    }

    /**

    /** Flag to allow insecure basic authentication */
    private boolean insecureBasic;

    /** The authentication realm */
    private String realm;

    /** The CIFS context for transport operations */
    private CIFSContext transportContext;

    @Override
    public void init(final ServletConfig config) throws ServletException {
        super.init(config);

        final Properties p = new Properties();

    //                                                                           Attribute
    //                                                                           =========
    /** Service for job log operations. */
    @Resource
    private JobLogService jobLogService;

    /** Pager for job log list pagination. */
    @Resource
    private JobLogPager jobLogPager;

import org.slf4j.LoggerFactory;

/**
 * RDMA buffer manager for efficient memory region pooling.
 *
 * Manages pools of pre-registered memory regions to avoid the overhead
 * of frequent registration/deregistration during RDMA operations.
 */
public class RdmaBufferManager implements AutoCloseable {

    private static final Logger log = LoggerFactory.getLogger(RdmaBufferManager.class);

    private final RdmaProvider provider;

/**
 * Utility class for document data manipulation and type conversion.
 * This class provides static methods for extracting typed values from document maps,
 * URL encoding, and other document-related operations. It's designed as a final
 * utility class with only static methods.
 *
 */
public final class DocumentUtil {

    /**
     * Private constructor to prevent instantiation of this utility class.
     */

import jcifs.internal.smb2.rdma.RdmaNegotiateRequest;
import jcifs.internal.smb2.rdma.RdmaNegotiateResponse;

/**
 * TCP-based RDMA connection implementation.
 *
 * Uses regular TCP sockets to simulate RDMA operations.
 * This provides a fallback when real RDMA hardware is not available.
 */
public class TcpRdmaConnection extends RdmaConnection {

    private static final Logger log = LoggerFactory.getLogger(TcpRdmaConnection.class);

import java.util.Objects;
import junit.framework.TestCase;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Test cases for {@link Table} read operations.
 *
 * @author Jared Levy
 */
@GwtCompatible
@NullMarked
public abstract class AbstractTableReadTest<C extends @Nullable Character> extends TestCase {
  protected Table<String, Integer, C> table;

  /**

import jakarta.annotation.PostConstruct;

/**
 * Configuration class for query field mappings in the Fess search engine.
 * This class manages field configurations for various query operations including
 * response fields, search fields, facet fields, sort fields, and highlighting.
 * It initializes field mappings from the FessConfig and provides methods to
 * query field properties and capabilities.
 */

        lenient().when(mockDcerpcBinding.getEndpoint()).thenReturn(TEST_ENDPOINT);
        lenient().when(mockContext.getBufferCache()).thenReturn(mockBufferCache);

        // Setup buffer cache to return buffers for sendrecv operations
        lenient().when(mockBufferCache.getBuffer()).thenReturn(new byte[8192]);
    }

    /**
     * Helper method to create a DcerpcPipeHandle with injected mocks

 * the License.
 */

package com.google.common.collect;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.collect.Iterators.emptyIterator;
import static com.google.common.collect.Iterators.singletonIterator;
import static com.google.common.truth.Truth.assertThat;
import static java.util.Arrays.asList;
import static org.junit.Assert.assertThrows;