multimap.put("foo", 3);
    multimap.put("foo", 1);
    multimap.put("foo", 7);
    multimap.put("tree", 4);
    multimap.put("tree", 0);
    return multimap;
  }

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

        assertEquals(2000, delay1);
        assertEquals(2000, delay2);
        assertEquals(2000, delay3);
    }

    @Test
    @DisplayName("Should provide meaningful toString output")
    void testToString() {
        // Given
        exception = new SmbOperationException(SmbOperationException.ErrorCode.ACCESS_DENIED, "Cannot access share");
        exception.withContext("share", "\\\\server\\share");

        // Assert
        assertEquals(0, result);
    }

    @Test
    @DisplayName("toString should return formatted string")
    void testToString() {
        // Act
        String result = response.toString();

        // Assert
        assertNotNull(result);
        assertTrue(result.contains("TransPeekNamedPipeResponse["));

    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("[]");

  }

  private static byte[] byteArrayWith9s(int size) {
    byte[] bytez = new byte[size];
    Arrays.fill(bytez, (byte) 0x99);
    return bytez;
  }

  public void testToString() {
    byte[] data = new byte[] {127, -128, 5, -1, 14};
    assertThat(HashCode.fromBytes(data).toString()).isEqualTo("7f8005ff0e");
    assertThat(base16().lowerCase().encode(data)).isEqualTo("7f8005ff0e");
  }

    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));
    assertThat(multiset.toString()).isEqualTo("[bar, foo x 2]");
  }

  public void testToString() {
    Multiset<String> ms = TreeMultiset.create();
    ms.add("a", 3);
    ms.add("c", 1);
    ms.add("b", 2);

    assertThat(ms.toString()).isEqualTo("[a x 3, b x 2, c]");
  }

            jsonPath = JsonPath.from(response);
            assertEquals(0, jsonPath.getInt("response.status"));
            assertEquals(logId, jsonPath.getString("response.log.id"));
            logger.info("Get crawling info log by ID test completed");
        }

        // Test GET with non-existent ID

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