fail("Expected exception for invalid Word document");
        } catch (final ExtractException e) {
            // ExtractException with improved message
            assertTrue("Error message should contain context about Word document or extraction",
                    e.getMessage().contains("Word") || e.getMessage().contains("extract"));
        } catch (final RuntimeException e) {

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

import jcifs.SmbTransport;
import jcifs.internal.CommonServerMessageBlock;

/**
 * Information about a multi-channel connection
 */
public class ChannelInfo {

    private final String channelId;
    private volatile SmbTransport transport;
    private final NetworkInterfaceInfo localInterface;

        // Allow: /public/*.html - should allow HTML files in public directory
        assertTrue(robotsTxt.allows("/public/index.html", "WildcardBot"));
        assertTrue(robotsTxt.allows("/public/about.html", "WildcardBot"));

        // Test EndPathBot - end-of-path ($) patterns
        // Disallow: /fish$ - should block exactly /fish but not /fishing
        assertFalse(robotsTxt.allows("/fish", "EndPathBot"));

import jcifs.internal.util.SMBUtil;
import jcifs.util.Hexdump;
import jcifs.util.Strings;
import jcifs.util.transport.Response;

/**
 * SMB1 Negotiate Protocol Response message.
 *
 * This response contains information about the server's capabilities,
 * security mode, and supported protocol version.
 */
public class SmbComNegotiateResponse extends ServerMessageBlock implements SmbNegotiationResponse {

        // Then
        assertEquals(cause, exception.getCause());
        assertNotNull(exception.getMessage());
        // The message should contain information about the cause
        assertTrue(exception.getMessage().contains("RuntimeException"));
        assertTrue(exception.getMessage().contains("Specific cause message"));
    }

        // But importantly, there should be no race condition errors
        assertEquals(threadCount, failureCount.get());
        assertEquals(0, successCount.get());

        // All exceptions should be about project ID being blank
        for (Exception e : exceptions) {
            assertTrue(e instanceof IOException);
            assertTrue(e.getMessage().contains("GCS_PROJECT_ID is blank"));
        }
    }

import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import jcifs.internal.util.SMBUtil;

/**
 * Information about a network interface for SMB3 Multi-Channel
 */
public class NetworkInterfaceInfo {

    private int interfaceIndex;
    private int capability;
    private int linkSpeed; // In units of 1 Mbps

 * <code>getByName</code>, and
 * <code>getAllByAddress</code> to create a new NbtAddress instance. This
 * class is symmetric with {@link java.net.InetAddress}.
 *
 *
 *  * <b>About NetBIOS:</b> The NetBIOS name
 * service is a dynamic distributed service that allows hosts to resolve
 * names by broadcasting a query, directing queries to a server such as

    class DoShareEnumValidation {

        static Stream<Arguments> invalidShareEnumCases() {
            return Stream.of(
                    // Missing trailing slash -> should complain about directory ending
                    Arguments.of("smb://server/share", "/share", true),
                    // Not a server root -> invalid list operation
                    Arguments.of("smb://server/share/", "/share/", false));

            // Groups information
            final int groupCount = pacStream.readInt();
            final int groupPointer = pacStream.readInt();

            // User flags about PAC Logon Info content
            this.userFlags = pacStream.readInt();
            final boolean hasExtraSids = (this.userFlags & PacConstants.LOGON_EXTRA_SIDS) == PacConstants.LOGON_EXTRA_SIDS;