// Configure OEM encoding to avoid NullPointerException
        when(mockConfig.getOemEncoding()).thenReturn("UTF-8");
    }

    @Test
    @DisplayName("Constructor with Configuration only should create empty Name instances")
    void testConstructorWithConfigOnly() {
        SessionRequestPacket packet = new SessionRequestPacket(mockConfig);

        assertNotNull(packet);

import junit.framework.AssertionFailedError;
import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

/**
 * A helper for concurrency testing. One or more {@code TestThread} instances are instantiated in a
 * test with reference to the same "lock-like object", and then their interactions with that object
 * are choreographed via the various methods on this class.
 *

 *
 * <p>The value of this expression will have the same sign as the <i>first nonzero</i> comparison
 * result in the chain, or will be zero if every comparison result was zero.
 *
 * <p><b>Note:</b> {@code ComparisonChain} instances are <b>immutable</b>. For this utility to work
 * correctly, calls must be chained as illustrated above.
 *
 * <p>Performance note: Even though the {@code ComparisonChain} caller always invokes its {@code

 * since an iteration across all row keys occurs.
 *
 * <p>Because a {@code TreeBasedTable} has unique sorted values for a given row, both {@code
 * row(rowKey)} and {@code rowMap().get(rowKey)} are {@link SortedMap} instances, instead of the
 * {@link Map} specified in the {@link Table} interface.
 *
 * <p>Note that this implementation is not synchronized. If multiple threads access this table

    } catch (IllegalArgumentException | UnsupportedOperationException expected) {
    }
  }

  // TODO: test adding element of wrong type

  /**
   * Returns {@link Method} instances for the {@code setCount()} tests that assume multisets support
   * duplicates so that the test of {@code Multisets.forSet()} can suppress them.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for {@link PairedStats}. This tests instances created by {@link
 * PairedStatsAccumulator#snapshot}.
 *
 * @author Pete Gillin
 */
@NullUnmarked
@J2ktIncompatible
@GwtIncompatible
public class PairedStatsTest extends TestCase {

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for {@link PairedStats}. This tests instances created by {@link
 * PairedStatsAccumulator#snapshot}.
 *
 * @author Pete Gillin
 */
@NullUnmarked
@J2ktIncompatible
@GwtIncompatible
public class PairedStatsTest extends TestCase {

    @Nullable ImmutableMapEntry<K, V>[] valueTable = createEntryArray(tableSize);
    /*
     * The cast is safe: n==entryArray.length means that we have filled the whole array with Entry
     * instances, in which case it is safe to cast it from an array of nullable entries to an array
     * of non-null entries.
     */
    @SuppressWarnings("nullness")
    Entry<K, V>[] entries =

 */
public final class IpAddressUtil {

    /**
     * Private constructor to prevent instantiation of utility class.
     */
    private IpAddressUtil() {
        // Utility class - no instances allowed
    }

    /**
     * Determines if the given address string represents an IPv6 address.
     * This method validates the address using InetAddress to ensure it's a valid IPv6 address.
     *

/**
 * A semi-persistent mapping from keys to values. Values are automatically loaded by the cache, and
 * are stored in the cache until either evicted or manually invalidated. The common way to build
 * instances is using {@link CacheBuilder}.
 *
 * <p>Implementations of this interface are expected to be thread-safe, and can be safely accessed
 * by multiple concurrent threads.
 *