assertEquals(0, smbInfoAllocation.getFree());
        }

        @Test
        @DisplayName("Should provide string representation")
        void testToString() {
            String result = smbInfoAllocation.toString();

            assertNotNull(result);
            assertTrue(result.contains("SmbInfoAllocation"));
            assertTrue(result.contains("alloc="));

    // Non-bracketed IPv6 fails.
    assertThrows(
        IllegalArgumentException.class,
        () -> HostAndPort.fromString("::1").requireBracketsForIPv6());
  }

  public void testToString() {
    // With ports.
    assertEquals("foo:101", "" + HostAndPort.fromString("foo:101"));
    assertEquals(":102", HostAndPort.fromString(":102").toString());

        assertThat(expectSuccess).isTrue();
      } catch (IllegalArgumentException e) {
        assertThat(expectSuccess).isFalse();
      }
    }
  }

  public void testToString() {
    for (long value : TEST_LONGS) {
      UnsignedLong unsignedValue = UnsignedLong.fromLongBits(value);
      assertThat(unsignedValue.toString()).isEqualTo(unsignedValue.bigIntegerValue().toString());
    }
  }

                break;
            }
        }
        assertTrue(foundTestMethod);
    }

    @Test
    @DisplayName("Should create meaningful string representation")
    void testToString() {
        // Given
        String message = "Test CIFS runtime error";
        RuntimeCIFSException exception = new RuntimeCIFSException(message);

        // When

        assertEquals(firstInstance.getSize(), secondInstance.getSize());
        assertEquals(expectedEndOfFile, secondInstance.getSize());
    }

    @Test
    @DisplayName("Test toString method")
    void testToString() throws SMBProtocolDecodingException {
        // Setup test data
        byte[] buffer = new byte[22];
        long expectedAllocationSize = 65536L;
        long expectedEndOfFile = 49152L;

    assertThrows(NumberFormatException.class, () -> UnsignedInts.decode("-0x5"));

    assertThrows(NumberFormatException.class, () -> UnsignedInts.decode("-05"));
  }

  public void testToString() {
    int[] bases = {2, 5, 7, 8, 10, 16};
    for (long a : UNSIGNED_INTS) {
      for (int base : bases) {
        assertThat(Long.toString(a, base)).isEqualTo(UnsignedInts.toString((int) a, base));
      }

        assertEquals(8, bytesRead);
        assertTrue(fileInfo.toString().contains("endOfFile=" + value));
    }

    @Test
    @DisplayName("Test toString format")
    void testToString() {
        // Test default constructor
        String str1 = fileInfo.toString();
        assertNotNull(str1);
        assertTrue(str1.startsWith("EndOfFileInformation["));

        int read = trans2FindFirst2.readDataWireFormat(buffer, 0, 100);

        assertEquals(0, read);
    }

    @Test
    @DisplayName("Test toString method")
    void testToString() {
        trans2FindFirst2 = new Trans2FindFirst2(mockConfig, "\\test\\path", "*.txt", 0x16, 50, 2048);

        String result = trans2FindFirst2.toString();

        assertNotNull(result);

        // Then
        assertEquals(0, bytesRead);
    }

    @Test
    @DisplayName("toString should return formatted string with details")
    void testToString() throws Exception {
        // Given
        String filename = "\\\\server\\share\\file.txt";
        trans2GetDfsReferral = new Trans2GetDfsReferral(mockConfig, filename);

    assertThrows(
        IllegalArgumentException.class,
        () -> Types.newParameterizedType(Map.class, String.class, Integer.class, Long.class));
  }

  public void testToString() {
    assertEquals(int[].class.getName(), Types.toString(int[].class));
    assertEquals(int[][].class.getName(), Types.toString(int[][].class));
    assertEquals(String[].class.getName(), Types.toString(String[].class));