import org.codelibs.fess.suggest.constants.SuggestConstants;

/**
 * Utility class for merging SuggestItem objects.
 * Centralizes merge logic to reduce complexity in SuggestItem.
 *
 * <p>This class provides methods for merging two SuggestItem instances,
 * combining their fields, frequencies, and other attributes while
 * maintaining uniqueness where appropriate.
 */
public final class SuggestItemMerger {

        baos.write(content);

        byte[] token = baos.toByteArray();
        assertThrows(PACDecodingException.class, () -> new KerberosToken(token));
    }

    // Helper methods to create test tokens

    private byte[] createGssApiWrapper(ASN1ObjectIdentifier oid, byte[] data) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

 *   <li>Offers useful operations beyond just {@code get} and {@code length}, so you don't have to
 *       hunt through classes like {@link Arrays} and {@link Doubles} for them.
 *   <li>Supports a copy-free {@link #subArray} view, so methods that accept this type don't need to
 *       add overloads that accept start and end indexes.
 *   <li>Can be streamed without "breaking the chain": {@code foo.getBarDoubles().stream()...}.

 *   <li>Offers useful operations beyond just {@code get} and {@code length}, so you don't have to
 *       hunt through classes like {@link Arrays} and {@link Ints} for them.
 *   <li>Supports a copy-free {@link #subArray} view, so methods that accept this type don't need to
 *       add overloads that accept start and end indexes.
 *   <li>Can be streamed without "breaking the chain": {@code foo.getBarInts().stream()...}.

        assertTrue(infoString.contains("sectPerAlloc=100"), "toString should contain sectPerAlloc");
        assertTrue(infoString.contains("bytesPerSect=512"), "toString should contain bytesPerSect");
    }

    // Helper methods to write numbers to byte array in little-endian format.
    private void writeInt2(int val, byte[] dst, int dstIndex) {
        dst[dstIndex++] = (byte) val;
        dst[dstIndex++] = (byte) (val >> 8);
    }

    public Strings() {
      // elements aren't sorted, to better test SortedSet iteration ordering
      super("b", "a", "c", "d", "e");
    }

    // for testing SortedSet and SortedMap methods
    public static final String BEFORE_FIRST = "\0";
    public static final String BEFORE_FIRST_2 = "\0\0";
    public static final String MIN_ELEMENT = "a";
    public static final String AFTER_LAST = "z";

import org.slf4j.LoggerFactory;

import jcifs.Configuration;
import jcifs.RuntimeCIFSException;

/**
 * Utility class for string manipulation and conversion operations in the jCIFS library.
 * Provides methods for encoding, decoding, and manipulating strings in SMB operations.
 *
 * @author mbechler
 */
public final class Strings {

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

    public Slf4jStdoutLogger() {
        this(System.out);
    }

    public Slf4jStdoutLogger(PrintStream out) {
        this.out = requireNonNull(out);
    }

    //
    // These are the only methods we need in our primordial logger
    //
    @Override
    public void error(String msg) {
        out.print(ERROR);
        out.println(msg);
    }

    @Override

      this.estimatedSize = estimatedSize;
    }

    /*
     * The tryAdvance and forEachRemaining in FlatMapSpliteratorOfPrimitive are overloads of these
     * methods, not overrides. They are annotated @Override because they implement methods from
     * Spliterator.OfPrimitive (and override default implementations from Spliterator.OfPrimitive or
     * a subtype like Spliterator.OfInt).
     */

    @Override

        // In real implementation, this would get the native memory address:
        // For direct ByteBuffers, this could be obtained through unsafe operations
        // or DiSNI-specific methods

        if (buffer.isDirect()) {
            // Assign a unique address to each buffer instance
            return bufferAddresses.computeIfAbsent(buffer, b -> addressCounter.getAndIncrement());
        } else {