assertThrows(SMBProtocolDecodingException.class, () -> echoResponse.readBytesWireFormat(buffer, bufferIndex));

            assertEquals("Expected structureSize = 4", exception.getMessage());
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 1, 2, 3, 5, 6, 100, 65535 })
        @DisplayName("Should throw exception for various invalid structure sizes")

        };

        try {
            stopwordsFile.reload(null, failingStream);
            fail("Should throw DictionaryException");
        } catch (DictionaryException e) {
            assertTrue(e.getMessage().contains("Failed to parse"));
        }
    }

    // Test update with InputStream
    public void test_update_withInputStream() throws IOException {
        String content = "new1\n" + "new2\n" + "new3\n";

                assertArrayEquals(ciphers, decoded.getCiphers());
            } catch (SMBProtocolDecodingException e) {
                fail("Should not throw exception: " + e.getMessage());
            }
        }

        @Test
        @DisplayName("Should verify cipher constants")
        void testCipherConstants() {
            // Verify the cipher constants are correctly defined

                writeSecurityBuffer(type1, 24, 32 + domain.length, workstation);
            }
            return type1;
        } catch (final IOException ex) {
            throw new IllegalStateException(ex.getMessage());
        }
    }

    @Override
    public String toString() {
        final String suppliedDomain = getSuppliedDomain();
        final String suppliedWorkstation = getSuppliedWorkstation();

  }

  private static void assertErrorMessage(Throwable e, String message) {
    // TODO(kevinb): use a Truth assertion here
    if (!e.getMessage().contains(message)) {
      fail("expected <" + e.getMessage() + "> to contain <" + message + ">");
    }
  }

  /**
   * Test class with valid equals and hashCode methods. Testers created with instances of this class

        when(treeConnection.hasCapability(999)).thenThrow(new SmbException("Not connected"));
        SmbException ex = assertThrows(SmbException.class, () -> handle.hasCapability(999));
        assertTrue(ex.getMessage().contains("Not connected"));
    }

    @Test
    @DisplayName("getTreeId delegates")
    void getTreeIdDelegates() {
        // Ensures tree id is forwarded from connection

        SmbException ex1 = assertThrows(SmbException.class, h::getFid);
        assertEquals("Descriptor is no longer valid", ex1.getMessage());
        SmbException ex2 = assertThrows(SmbException.class, h::getFileId);
        assertEquals("Descriptor is no longer valid", ex2.getMessage());
    }

    @Test
    @DisplayName("close(long) sends SMB2 close request and releases tree when SMB2")

            // Expected
            assertTrue(e.getMessage().contains("INVALID"));
        }

        try {
            CrawlerStatus.valueOf("initializing"); // lowercase
            fail("Should throw IllegalArgumentException for lowercase value");
        } catch (IllegalArgumentException e) {
            // Expected
            assertTrue(e.getMessage().contains("initializing"));
        }

        try {

            }
            assertImageSize(outputFile, 100, 100);
        } catch (IllegalStateException e) {
            // Expected when container is not initialized
            if (e.getMessage().contains("Not initialized")) {
                // Skip test when container is not available
                return;
            }
            throw e;
        }
    }

                    "Should throw when structure size != 4");

            // Assert: message is meaningful
            assertEquals("Structure size is not 4", ex.getMessage());
        }

        @Test
        @DisplayName("Null buffer leads to NullPointerException from readInt2")
        void nullBuffer_throwsNPE() {
            // Arrange