/**
     * @throws Exception
     */
    @Test
    public void testGetFromStream() throws Exception {
        final String path = ClassUtil.getPackageName(this.getClass()).replaceAll("\\.", "/") + "/aaa.html";
        final String contentType = MimeTypeUtil.guessContentType(path);
        assertEquals("text/html", contentType);
    }

    /**
     * @throws Exception
     */
    @Test

    public boolean isGroupAddress(final CIFSContext tc) throws UnknownHostException {
        checkData(tc);
        return this.groupName;
    }

    @Override
    public int getNodeType(final CIFSContext tc) throws UnknownHostException {
        checkData(tc);
        return this.nodeType;
    }

    @Override
    public boolean isBeingDeleted(final CIFSContext tc) throws UnknownHostException {

      if (!response.isSuccessful) throw IOException("Unexpected code $response")
      println(response.body.string())
    }
  }

  private class ProgressRequestBody(
    private val delegate: RequestBody,
    private val progressListener: ProgressListener,
  ) : RequestBody() {
    override fun contentType() = delegate.contentType()

    @Throws(IOException::class)

        }
        printBoostAndQueryName(builder);
        builder.endObject();
    }

    @Override
    protected Query doToQuery(final QueryShardContext context) throws IOException {
        throw new UnsupportedOperationException("Query processing is not supported.");
    }

    @Override
    protected boolean doEquals(final StoredLtrQueryBuilder other) {

        assertEquals(lastName.toUpperCase(), writtenLastName);
    }

    @Test
    @DisplayName("Test writeParametersWireFormat with null lastName for NET_SERVER_ENUM3 throws NPE")
    void testWriteParametersWireFormatNetServerEnum3NullLastName() throws Exception {
        String domain = "WORKGROUP";
        int serverTypes = NetServerEnum2.SV_TYPE_ALL;

        netServerEnum2 = new NetServerEnum2(realConfig, domain, serverTypes);

    @BeforeEach
    void setUp() {
        transactionMock = mock(SmbComTransactionResponse.class);
    }

    @Test
    void testSmbComQueryInformationResponseGetters() throws Exception {
        // The constructor is package‑private; use an anonymous subclass
        SmbComQueryInformationResponse resp = new SmbComQueryInformationResponse(1000L) {
        };

        assertNull(context.getSigningKey()); // Signing key should not be generated
    }

    @Test
    void testInitSecContext_invalidState() throws SmbException {
        // Test that calling initSecContext in an invalid state throws an exception
        when(mockAuth.getDomain()).thenReturn(domain);
        when(mockAuth.getUsername()).thenReturn(username);
        when(mockAuth.getPassword()).thenReturn(password);

/**
 * @author shinsuke
 *
 */
public class TextTransformerTest extends PlainTestCase {
    public TextTransformer textTransformer;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        StandardCrawlerContainer container = new StandardCrawlerContainer().singleton("extractorFactory", ExtractorFactory.class)
                .singleton("textTransformer", TextTransformer.class)

        return mockCtx;
    }

    @Test
    @DisplayName("Should create Type 3 message with authentication data")
    void testType3MessageCreation() throws Exception {
        // Given
        Type2Message type2 = createMockType2Message();
        String password = "testpassword";
        String domain = "TESTDOMAIN";
        String username = "testuser";

     * @param type The type of toolchain to retrieve
     * @return List of matching toolchains, never null
     * @throws ToolchainManagerException if toolchain retrieval fails
     */
    @Nonnull
    default List<Toolchain> getToolchains(@Nonnull Session session, @Nonnull String type)
            throws ToolchainManagerException {
        return getToolchains(session, type, null);
    }

    /**