else -> testData.base!!.toHttpUrl().resolve(testData.input!!)
      }

    if (testData.expectParseFailure()) {
      assertThat(url, "Expected URL to fail parsing").isNull()
      return
    }

    assertThat(url, "Expected URL to parse successfully, but was null")
      .isNotNull()
    val effectivePort =
      when {
        url!!.port != defaultPort(url.scheme) -> Integer.toString(url.port)

    Collection<V> values = multimap().get(k3());
    if (values.size() == 0) {
      expectUnchanged();
      // Be extra thorough in case internal state was corrupted by the expected null.
      assertEquals(new ArrayList<>(), new ArrayList<>(values));
      assertEquals(size, multimap().size());
    } else {
      assertEquals(newArrayList(v3()), new ArrayList<>(values));

        for (Thread thread : threads) {
            thread.join();
        }

        // All threads should get the same instance
        LogStream expected = instances[0];
        for (LogStream instance : instances) {
            assertSame(expected, instance);
        }
    }

    return new HashMultiset<>();
  }

  /**
   * Creates a new, empty {@code HashMultiset} with the specified expected number of distinct
   * elements.
   *
   * @param distinctElements the expected number of distinct elements
   * @throws IllegalArgumentException if {@code distinctElements} is negative
   */

./mc version suspend sitea/delissue --insecure

./mc rm sitea/delissue/hello --insecure

count=$(./mc ls --versions sitea/delissue --insecure | wc -l)

if [ ${count} -ne 3 ]; then
	echo "BUG: expected number of versions to be '3' found ${count}"
	echo "===== DEBUG ====="
	./mc ls --versions sitea/delissue
fi

./mc mb sitea/testbucket

./mc version enable sitea/testbucket

    ByteBuffer buffer = ByteBuffer.wrap(combined);
    buffer.put(md5Hash);
    buffer.put(murmur3Hash);
    HashCode expected = HashCode.fromBytes(combined);

    assertEquals(
        expected, Hashing.concatenating(Hashing.md5(), Hashing.murmur3_32()).hashLong(42L));
    assertEquals(
        expected, Hashing.concatenating(asList(Hashing.md5(), Hashing.murmur3_32())).hashLong(42L));
  }

pkg p1, type I interface, PackageTwoMeth()
pkg p1, type I interface, Set(string, int64)
pkg p1, type I interface, unexported methods
pkg p1, type MyInt int
pkg p1, type Namer interface { Name }
pkg p1, type Namer interface, Name() string
pkg p1, type Private //deprecated
pkg p1, type Private interface, X()
pkg p1, type Private interface, unexported methods
pkg p1, type Public interface { X, Y }
pkg p1, type Public interface, X()

   * href="#bitEquals">bitwise equal</a> to the expected value.
   *
   * @param expect the expected value
   * @param update the new value
   * @return {@code true} if successful. False return indicates that the actual value was not
   *     bitwise equal to the expected value.
   */
  public final boolean compareAndSet(double expect, double update) {

        // We verify the method handles the case gracefully
        try {
            emptyGenerator.isTarget(docMap);
        } catch (IllegalStateException e) {
            // Expected when container is not initialized
            assertTrue(e.getMessage().contains("Not initialized"));
        }
    }

    public void test_getName() {
        // Initialize without container

        Smb2LogoffRequest req = newRequest();
        int base = Smb2Constants.SMB2_HEADER_LENGTH + 4; // structure size
        int expected = ((base + 7) / 8) * 8; // expected 8-byte alignment

        // Act
        int actual = req.size();

        // Assert
        assertEquals(expected, actual, "size() must be 8-byte aligned");
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 5 })