assertEquals(a.length(), b.length());
    for (int i = 0; i < VALUES.length; i++) {
      assertBitEquals(a.get(i), b.get(i));
    }
  }

  /** toString returns current value */
  public void testToString() {
    AtomicDoubleArray aa = new AtomicDoubleArray(VALUES);
    assertThat(aa.toString()).isEqualTo(Arrays.toString(VALUES));
    assertThat(new AtomicDoubleArray(0).toString()).isEqualTo("[]");

                .hash()
                .toString())
        .isEqualTo("9753980fe94daa8ecaa82216519393a9");
    assertThrows(IllegalStateException.class, hasher::hash);
  }

  public void testToString() {
    byte[] keyData = "secret key".getBytes(UTF_8);

    assertThat(hmacMd5(MD5_KEY).toString())
        .isEqualTo("Hashing.hmacMd5(Key[algorithm=HmacMD5, format=RAW])");

      assertThat(length - baseStackDepth).isLessThan(DIRECT_EXECUTIONS_PER_THREAD / 2);
    }
  }

  @SuppressWarnings("ObjectToString") // Intended behavior
  public void testToString() {
    Future<?> unused = serializer.submitAsync(firstCallable, directExecutor());
    TestCallable secondCallable = new TestCallable(SettableFuture.create());

        assertThrows(Exception.class, () -> {
            transformHeader.encode(shortBuffer, 0);
        });
    }

    @Test
    @DisplayName("Should create string representation")
    void testToString() {
        // Given
        transformHeader.setSessionId(testSessionId);
        transformHeader.setOriginalMessageSize(1024);
        transformHeader.setFlags(0x0001);

        // When

    // The radix is used as an array index, so try a negative value.
    assertThrows(NumberFormatException.class, () -> UnsignedBytes.parseUnsignedByte("0", -1));
  }

  public void testToString() {
    // We can easily afford to test this exhaustively.
    for (int i = 0; i <= 0xff; i++) {
      assertThat(UnsignedBytes.toString((byte) i)).isEqualTo(Integer.toString(i));
    }
  }

        assertFalse(nbtAddress1.equals(nbtAddress3));
        assertFalse(nbtAddress1.equals(null));
        assertFalse(nbtAddress1.equals("some string"));
    }

    @Test
    void testToString() {
        // Test toString method
        mockName = new Name(mockConfig, "TESTHOST", 0x00, null);
        NbtAddress nbtAddress = new NbtAddress(mockName, testAddressInt, false, NbtAddress.H_NODE);

        SmbShareInfo share = (SmbShareInfo) results[0];
        assertEquals(remark, share.remark);
    }

    @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);

        assertEquals(0, fileBothDirectoryInfo.length());
        assertEquals(0, fileBothDirectoryInfo.getAttributes());
    }

    @Test
    @DisplayName("Test toString method contains all fields")
    void testToString() throws SMBProtocolDecodingException {
        // Prepare test data
        byte[] buffer = createValidBuffer("tostring.txt", "TOSTRI~1.TXT", true);
        long testTime = System.currentTimeMillis();

            // Then: Should complete without errors
            assertDoesNotThrow(() -> handle.close());
        }

        @Test
        @DisplayName("Should return string representation")
        void testToString() {
            // Given: Mock binding with toString
            when(mockBinding.toString()).thenReturn("mockBindingString");

            // When: Getting string representation

        long expectedFree = (long) free * sectPerAlloc * bytesPerSect;
        assertEquals(expectedFree, smbInfoAllocation.getFree());
    }

    @Test
    @DisplayName("Test toString method")
    void testToString() throws SMBProtocolDecodingException {
        // Prepare test data
        byte[] buffer = new byte[22];
        int idFileSystem = 0xABCDEF00;
        int sectPerAlloc = 4;
        long alloc = 500000L;