assertTrue(length > 0);
        // andxCommand is private, but we can verify the behavior
        assertNull(testBlock.getAndx());
    }

    @Test
    @DisplayName("Test toString method")
    void testToString() {
        when(mockAndxCommand.getCommand()).thenReturn(0x42);
        testBlock = new TestAndXServerMessageBlock(mockConfig, (byte) 0x25, mockAndxCommand);

        String result = testBlock.toString();

        assertEquals(12, read);
        assertEquals(0x1234, packet.nameTrnId);
        assertEquals(1, packet.questionCount);
    }

    @Test
    void testToString() throws UnknownHostException {
        packet.nameTrnId = 1;
        packet.isResponse = true;
        packet.opCode = NameServicePacket.QUERY;
        packet.isAuthAnswer = true;
        packet.isTruncated = true;

    multimap.put("foo", 5);
    multimap.put("bar", 4);
    multimap.put("foo", 3);
    multimap.put("cow", 2);
    multimap.put("bar", 1);
    return multimap;
  }

  public void testToString() {
    SetMultimap<String, Integer> multimap = LinkedHashMultimap.create();
    multimap.put("foo", 3);
    multimap.put("bar", 1);
    multimap.putAll("foo", asList(-1, 2, 4));

        }
    }

    @Nested
    @DisplayName("ToString Tests")
    class ToStringTests {

        @Test
        @DisplayName("Should generate correct string representation")
        void testToString() {
            when(mockReferral.getTtl()).thenReturn(600);
            when(mockReferral.getRFlags()).thenReturn(4);
            when(mockReferral.getNode()).thenReturn("\\server.example.com\\share\\folder");

    assertSame(c, copyOf(c));
  }

  public void testCopyOf_shortcut_sameType() {
    Collection<String> c = of("a", "b", "c");
    assertSame(c, copyOf(c));
  }

  public void testToString() {
    Set<String> set = of("a", "b", "c", "d", "e", "f", "g");
    assertEquals("[a, b, c, d, e, f, g]", set.toString());
  }

  @GwtIncompatible // slow (~40s)
  public void testIterator_oneElement() {

        NegotiateContextResponse unknown = Smb2NegotiateResponse.createContext(0x9999);
        assertNull(unknown);
    }

    @Test
    @DisplayName("Should generate correct toString")
    void testToString() throws Exception {
        // Given
        setPrivateField(response, "dialectRevision", 0x0311);
        setPrivateField(response, "securityMode", 0x01);
        setPrivateField(response, "capabilities", 0x7F);

            // Then
            assertEquals(0, bytesWritten, "Should write 0 bytes for response");
        }

        @Test
        @DisplayName("Should generate correct toString representation")
        void testToString() throws Exception {
            // Given
            setPrivateField(response, "supportSearchBits", true);
            setPrivateField(response, "shareIsInDfs", true);

        assertEquals("\\\\alt", referral.getAltPath());
        assertEquals("NODE", referral.getNode());
    }

    // ToString Tests

    @Test
    public void testToString() {
        ByteBuffer bb = ByteBuffer.wrap(testBuffer).order(ByteOrder.LITTLE_ENDIAN);

        bb.putShort((short) 3);
        bb.putShort((short) 200); // increased size
        bb.putShort((short) 1);

        assertTrue(result.contains("commentOrMasterBrowser=Test server"));
        assertTrue(result.endsWith("]"));
    }

    @Test
    @DisplayName("Test toString method")
    void testToString() throws Exception {
        // Set some test values
        setStatus(response, 0);
        setConverter(response, 100);
        setNumEntries(response, 2);
        setTotalAvailableEntries(response, 5);

      for (int i = 0; i < bytes.length; i++) {
        assertThat(decodingStream.read()).isEqualTo(bytes[i] & 0xFF);
      }
      assertThat(decodingStream.read()).isEqualTo(-1);
    }
  }

  public void testToString() {
    assertThat(base64().toString()).isEqualTo("BaseEncoding.base64().withPadChar('=')");
    assertThat(base32Hex().omitPadding().toString())
        .isEqualTo("BaseEncoding.base32Hex().omitPadding()");