}

  private void assertOrderingReadOnly(Multimap<String, Integer> multimap) {
    assertThat(multimap.get("foo")).containsExactly(5, 3).inOrder();
    assertThat(multimap.get("bar")).containsExactly(4, 1).inOrder();
    assertThat(multimap.get("cow")).contains(2);

    assertThat(multimap.keySet()).containsExactly("foo", "bar", "cow").inOrder();
    assertThat(multimap.values()).containsExactly(5, 4, 3, 2, 1).inOrder();

            0x000002, 0x000001 };
    private static byte[] pc1 = { (byte) 56, (byte) 48, (byte) 40, (byte) 32, (byte) 24, (byte) 16, (byte) 8, (byte) 0, (byte) 57,
            (byte) 49, (byte) 41, (byte) 33, (byte) 25, (byte) 17, (byte) 9, (byte) 1, (byte) 58, (byte) 50, (byte) 42, (byte) 34,
            (byte) 26, (byte) 18, (byte) 10, (byte) 2, (byte) 59, (byte) 51, (byte) 43, (byte) 35, (byte) 62, (byte) 54, (byte) 46,

      // (result + 0.5)^2 * 4 = (result^2 + result)*4 + 1
      assertThat(plusHalfSquared).isGreaterThan(x4);
      BigInteger minusHalfSquared = result.pow(2).subtract(result).shiftLeft(2).add(ONE);
      // sqrt(x) > result - 0.5, so 4 * x > (result - 0.5)^2 * 4
      // (result - 0.5)^2 * 4 = (result^2 - result)*4 + 1
      assertTrue(result.equals(ZERO) || x4.compareTo(minusHalfSquared) >= 0);
    }
  }

    other is CertificatePinner &&
      other.pins == pins &&
      other.certificateChainCleaner == certificateChainCleaner

  override fun hashCode(): Int {
    var result = 37
    result = 41 * result + pins.hashCode()
    result = 41 * result + certificateChainCleaner.hashCode()
    return result
  }

  /** A hostname pattern and certificate hash for Certificate Pinning. */
  class Pin(
    pattern: String,

            // Create a buffer and write
            byte[] buffer = new byte[256];
            int bytesWritten = request.writeBytesWireFormat(buffer, 64);

            // Verify structure size (should be 41)
            assertEquals(41, SMBUtil.readInt2(buffer, 64));

            // Verify info type and file info class
            assertEquals((byte) 0x01, buffer[66]);
            assertEquals((byte) 0x04, buffer[67]);

  }

  private void assertOrderingReadOnly(Multimap<String, Integer> multimap) {
    assertThat(multimap.get("foo")).containsExactly(5, 3).inOrder();
    assertThat(multimap.get("bar")).containsExactly(4, 1).inOrder();
    assertThat(multimap.get("cow")).contains(2);

    assertThat(multimap.keySet()).containsExactly("foo", "bar", "cow").inOrder();
    assertThat(multimap.values()).containsExactly(5, 4, 3, 2, 1).inOrder();

http://example.com/foo%2zbar  s:http h:example.com p:/foo%2zbar
http://example.com/foo%2\u00C2\u00A9zbar  s:http h:example.com p:/foo%2%C3%82%C2%A9zbar
http://example.com/foo%41%7a  s:http h:example.com p:/foo%41%7a
http://example.com/foo\t\u0091%91  s:http h:example.com p:/foo%C2%91%91
http://example.com/foo%00%51  s:http h:example.com p:/foo%00%51
http://example.com/(%28:%3A%29)  s:http h:example.com p:/(%28:%3A%29)

        buffer[37] = 0x00;
        buffer[38] = 0x00;

        // Parameter count (2 bytes)
        buffer[39] = 0x00;
        buffer[40] = 0x00;

        // Parameter offset (2 bytes)
        buffer[41] = 0x00;
        buffer[42] = 0x00;

        // Parameter displacement (2 bytes)
        buffer[43] = 0x00;
        buffer[44] = 0x00;

        // Data count (2 bytes)
        buffer[45] = 0x00;

    void testDecode() {
        byte[] buffer = new byte[1024];
        // Fill with basic SMB header structure
        System.arraycopy(new byte[] { (byte) 0xFF, 'S', 'M', 'B' }, 0, buffer, 0, 4);
        buffer[4] = 1; // wordCount
        buffer[7] = 0; // byteCount low
        buffer[8] = 0; // byteCount high

        assertDoesNotThrow(() -> response.decode(buffer, 0));
    }

    @Test

  val normalized = normalizeNfc(bufferB.readUtf8())
  bufferA.writeUtf8(normalized)

  // 3. For each label, convert/validate Punycode.
  val decoded = Punycode.decode(bufferA.readUtf8()) ?: return null

  // 4.1 Validate.

  // Must be NFC.
  if (decoded != normalizeNfc(decoded)) return null

  // TODO: Must not begin with a combining mark.
  // TODO: Each character must be 'valid' or 'deviation'. Not mapped.