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

	}
	if encOff != 595127964 {
		t.Fatalf("Test: expected %d, got %d", 595127964, encOff)
	}
	if encLength != 32796 {
		t.Fatalf("Test: expected %d, got %d", 32796, encLength)
	}
	if skipLen != 32756 {
		t.Fatalf("Test: expected %d, got %d", 32756, skipLen)
	}
	if seqNumber != 4538 {
		t.Fatalf("Test: expected %d, got %d", 4538, seqNumber)
	}
	if partStart != 1 {

      fail("Expected NoSuchElementException.");
    } catch (NoSuchElementException expected) {
    }
  }

  private <T> void assertPermutationsCount(int expected, Collection<List<T>> permutationSet) {
    assertEquals(expected, permutationSet.size());
    Iterator<List<T>> permutations = permutationSet.iterator();
    for (int i = 0; i < expected; i++) {
      assertTrue(permutations.hasNext());
      permutations.next();
    }

  @Test
  fun readIndexedHeaderFieldIndex0() {
    bytesIn.writeByte(0x80) // == Indexed - Add idx = 0
    assertFailsWith<IOException> {
      hpackReader!!.readHeaders()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("index == 0")
    }
  }

  // Example taken from twitter/hpack DecoderTest.testIllegalIndex
  @Test
  fun readIndexedHeaderFieldTooLargeIndex() {

  static void testSort(byte[] input, byte[] expected) {
    input = Arrays.copyOf(input, input.length);
    UnsignedBytes.sort(input);
    assertThat(input).isEqualTo(expected);
  }

  static void testSort(byte[] input, int from, int to, byte[] expected) {
    input = Arrays.copyOf(input, input.length);
    UnsignedBytes.sort(input, from, to);
    assertThat(input).isEqualTo(expected);
  }

  public void testSortIndexed() {

                (byte) 0x0b, (byte) 0x0b, (byte) 0x0b, (byte) 0x0b, (byte) 0x0b, (byte) 0x0b, (byte) 0x0b };
        byte[] data = "Hi There".getBytes();

        // Calculate expected HMACT64 result manually
        MessageDigest md5 = MessageDigest.getInstance("MD5");
        byte[] ipad = new byte[64];
        byte[] opad = new byte[64];

        SmbComLogoffAndX msg = new SmbComLogoffAndX(null);
        assertEquals(0, msg.writeParameterWordsWireFormat(new byte[10], index), "Expected zero returned regardless of index");
        assertEquals(0, msg.writeParameterWordsWireFormat(null, index), "Expected zero even when dst array is null");
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 3, 9, -5 })

class PreparePatchReleaseTest extends Specification {

    def "patch version is correctly bumped"() {
        expect:
        ReleasedVersionsHelperKt.bumpPatchVersion(input) == expected

        where:
        input   | expected
        "9.4.0" | "9.4.1"
        "9.4.1" | "9.4.2"
        "8.0.0" | "8.0.1"
        "1.2.3" | "1.2.4"
    }

    def "invalid version format is rejected"() {
        when:

			gotMeta, dangling := isObjectDangling(testCase.metaArr, testCase.errs, testCase.dataErrs)
			if !gotMeta.Equals(testCase.expectedMeta) {
				t.Errorf("Expected %#v, got %#v", testCase.expectedMeta, gotMeta)
			}
			if dangling != testCase.expectedDangling {
				t.Errorf("Expected dangling %t, got %t", testCase.expectedDangling, dangling)
			}
		})
	}
}

// Tests both object and bucket healing.

			versionsSorter(fivs.Versions).reverse()

			var decommissioned, expired int
			for _, version := range fivs.Versions {
				stopFn := globalDecommissionMetrics.log(decomMetricDecommissionObject, idx, bi.Name, version.Name, version.VersionID)
				// Apply lifecycle rules on the objects that are expired.
				if filterLifecycle(bi.Name, version.Name, version) {
					expired++
					decommissioned++