i += 12;
        if (len != 0) {
            len--;
            final int size = len * 2;
            if (size < 0 || size > 0xFFFF) {
                throw new NdrException(NdrException.INVALID_CONFORMANCE);
            }
            val = Strings.fromUNIBytes(this.buf, i, size);
            i += size + 2;
        }
        advance(i - this.index);
        return val;
    }

            size += workstationBytes.length;
        }

        final byte[] micBytes = getMic();
        if (micBytes != null) {
            size += 8 + 16;
        } else if (getFlag(NTLMSSP_NEGOTIATE_VERSION)) {
            size += 8;
        }

        final byte[] lmResponseBytes = getLMResponse();
        size += lmResponseBytes != null ? lmResponseBytes.length : 0;

    }

    @Test
    @DisplayName("Test invalid buffer size validation")
    void testInvalidBufferSize() {
        assertThrows(IllegalArgumentException.class, () -> InputValidator.validateBufferSize(-1, 1000, "test"));
        assertThrows(IllegalArgumentException.class, () -> InputValidator.validateBufferSize(1001, 1000, "test"));
    }

    @Test
    @DisplayName("Test SMB2 buffer size validation")
    void testSmb2BufferSize() {

        if (this.realm == null && this.getSubject() != null) {
            Set<Principal> pr = this.getSubject().getPrincipals();
            for (Iterator<Principal> ite = pr.iterator(); ite.hasNext();) {
                try {
                    KerberosPrincipal entry = (KerberosPrincipal) ite.next();
                    return entry.getRealm();
                } catch (Exception e) {
                    continue;
                }

        private final long size;
        private final long lastModified;
        private final boolean isDirectory;
        private final long attributes;
        private final long creationTime;
        private final long lastAccessTime;
        
        public FileInfo(String name, SmbFileAttributes attrs) {
            this.name = name;
            this.size = attrs.getSize();

                throw new IOException("transport closed in negotiate");
            }
            final int size = Encdec.dec_uint16be(sbuf, 2) & 0xFFFF;
            if (size < 33 || 4 + size > sbuf.length) {
                throw new IOException("Invalid payload size: " + size);
            }
            readn(in, sbuf, 4 + 32, size - 32);
            resp.decode(sbuf, 4);

            if (LogStream.level >= 4) {

                    1024L * 1024L * 1024L * 1024L * 10L // 10 TB
            };

            for (long size : typicalSizes) {
                TestAllocInfo allocInfo = new TestAllocInfo(size, size / 2);
                assertEquals(size, allocInfo.getCapacity());
                assertEquals(size / 2, allocInfo.getFree());
            }
        }
    }

    @Nested
    @DisplayName("Usage Pattern Tests")

 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.smb2.multichannel;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicLong;

 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.spnego;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Enumeration;

        assertEquals(8192, receiveBufferSize, "Should delegate receive buffer size");
        assertEquals(65536, maximumBufferSize, "Should delegate maximum buffer size");
        assertEquals(65024, transactionBufferSize, "Should delegate transaction buffer size");
        assertEquals(16, bufferCacheSize, "Should delegate buffer cache size");