void testEncodeVariousHashAlgoCounts(int algoCount) {
            int[] hashAlgos = new int[algoCount];
            for (int i = 0; i < algoCount; i++) {
                hashAlgos[i] = i + 1;
            }
            byte[] salt = { 0x01, 0x02 };
            PreauthIntegrityNegotiateContext context = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            int bytesWritten = context.encode(buffer, 0);

     * most 3 components (not including the first index which is always empty):
     * result[0] = ""
     * result[1] = "fs1.example.com"
     * result[2] = "root5"
     * result[3] = "link2\foo\bar.txt"
     */
    private static int dfsPathSplit(final String path, final String[] result) {
        int ri = 0;
        final int rlast = result.length - 1;
        int i = 0, b = 0;

    }

    @ParameterizedTest
    @DisplayName("Should handle various element counts")
    @ValueSource(ints = { 1, 2, 5, 10, 20, 50, 100 })
    void testJoinWithVariousElementCounts(int count) {
        CharSequence[] elements = new CharSequence[count];
        for (int i = 0; i < count; i++) {
            elements[i] = String.valueOf(i);
        }
        String result = StringUtil.join(",", elements);

    void testWriteSetupWireFormatWithVariousFids(int fid, byte expectedLow, byte expectedHigh) {
        // Arrange
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, fid);
        byte[] buffer = new byte[10];
        int offset = 0;

        // Act
        int bytesWritten = transPeekNamedPipe.writeSetupWireFormat(buffer, offset);

        // Assert

        void testSizeCalculation(int hashAlgoCount) {
            // Arrange
            int[] hashAlgos = new int[hashAlgoCount];
            byte[] salt = new byte[16];
            context = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            // Act
            int size = context.size();

            // Assert
            assertEquals(4 + (2 * hashAlgoCount) + 16, size);

    }

    @ParameterizedTest
    @ValueSource(ints = { NtlmFlags.NTLMSSP_NEGOTIATE_UNICODE, NtlmFlags.NTLMSSP_NEGOTIATE_OEM, NtlmFlags.NTLMSSP_NEGOTIATE_NTLM,
            NtlmFlags.NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED, NtlmFlags.NTLMSSP_NEGOTIATE_OEM_WORKSTATION_SUPPLIED })
    @DisplayName("Should handle various NTLM flags")
    void testVariousNTLMFlags(int flag) {
        // When

    static final int DEFAULT_SO_TIMEOUT = 5000;
    static final int DEFAULT_RCV_BUF_SIZE = 576;
    static final int DEFAULT_SND_BUF_SIZE = 576;
    static final int NAME_SERVICE_UDP_PORT = 137;
    static final int DEFAULT_RETRY_COUNT = 2;
    static final int DEFAULT_RETRY_TIMEOUT = 3000;

    static final int RESOLVER_LMHOSTS = 1;
    static final int RESOLVER_BCAST = 2;

    @ValueSource(ints = { 1024, 2048, 4096, 8192, 16384, 32768, 65535 })
    void testMaxDataCountValues(int maxDataCount) throws Exception {
        netShareEnum = new NetShareEnum(realConfig);

        // Set maxDataCount using reflection
        setFieldValue(netShareEnum, "maxDataCount", maxDataCount);

        byte[] dst = new byte[256];

            // Verify each is a power of 2
            for (int cap : capabilities) {
                assertTrue(isPowerOfTwo(cap), "Capability 0x" + Integer.toHexString(cap) + " should be a power of 2");
            }

            // Verify no overlapping bits
            for (int i = 0; i < capabilities.length; i++) {
                for (int j = i + 1; j < capabilities.length; j++) {

import java.util.Iterator;
import java.util.NoSuchElementException;

import org.codelibs.core.exception.ClUnsupportedOperationException;

/**
 * Adaptor that makes an array into an {@link Iterator}.
 * <p>
 * Usage example:
 * </p>
 *
 * <pre>
 * import static org.codelibs.core.collection.ArrayIterator.*;
 *
 * String[] array = ...;
 * for (String element : iterable(array)) {