assertTrue(tlsVersion == TlsVersion.TLS_1_2 || tlsVersion == TlsVersion.TLS_1_3)
      assertEquals(
        "CN=localhost",
        (response.handshake!!.peerCertificates.first() as X509Certificate).subjectDN.name,
      )
    }
  }

  @Test
  fun testCertificatePinningFailure() {
    enableTls()

    val certificatePinner =
      CertificatePinner

looking through interesting issues. If you are not sure of where to start, then
start by trying one of the smaller/easier issues here i.e.
[issues with the "good first issue" label](https://github.com/tensorflow/tensorflow/labels/good%20first%20issue)
and then take a look at the

        final byte[] nonce = new byte[isGCMCipher() ? 16 : 12];

        if (isGCMCipher()) {
            // SMB 3.1.1 GCM: 96-bit random/fixed + 32-bit counter for guaranteed uniqueness
            // Fill first 12 bytes with random data
            secureRandom.nextBytes(nonce);

            // Last 4 bytes: incrementing counter for guaranteed uniqueness
            final long counter = this.nonceCounter.incrementAndGet();

      assertTrue(
          IntMath.biggestBinomials[k] == Integer.MAX_VALUE
              || !fitsInInt(BigIntegerMath.binomial(IntMath.biggestBinomials[k] + 1, k)));
      // In the first case, any int is valid; in the second, we want to test that the next-bigger
      // int overflows.
    }
    assertFalse(
        fitsInInt(
            BigIntegerMath.binomial(

### Suggest solutions { #suggest-solutions }

* After being able to understand the question, you can give them a possible **answer**.

   * http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.4
   */
  @Test
  fun responseCachingByResponseCode() {
    // Test each documented HTTP/1.1 code, plus the first unused value in each range.
    // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html

    // We can't test 100 because it's not really a response.
    // assertCached(false, 100);
    assertCached(false, 101)

            // Then
            assertEquals(EXPECTED_SIZE, offset1);
            assertEquals(EXPECTED_SIZE, offset2);
            assertEquals(EXPECTED_SIZE, offset3);

            // Verify first chunk
            assertEquals(100L, SMBUtil.readInt8(buffer, 0));
            assertEquals(200L, SMBUtil.readInt8(buffer, 8));
            assertEquals(300, SMBUtil.readInt4(buffer, 16));

        assertSame(mirrorC, mirrorSelector.getMirror(getRepo("c", "http://c.c"), mirrors));
    }

    @Test
    void testMirrorStopOnFirstMatch() {
        // exact matches win first
        Mirror mirrorA2 = newMirror("a2", "a,b", "http://a2");
        Mirror mirrorA = newMirror("a", "a", "http://a");
        // make sure repeated entries are skipped

type ServerSystemConfig struct {
	NEndpoints int
	CmdLines   []string
	MinioEnv   map[string]string
	Checksum   string
}

// Diff - returns error on first difference found in two configs.
func (s1 *ServerSystemConfig) Diff(s2 *ServerSystemConfig) error {
	if s1.Checksum != s2.Checksum {
		return fmt.Errorf("Expected MinIO binary checksum: %s, seen: %s", s1.Checksum, s2.Checksum)
	}

| `minio_s3_requests_waiting_total`             | Number of S3 requests in the waiting queue.              |
| `minio_s3_requests_ttfb_seconds_distribution` | Distribution of the time to first byte across API calls. |
| `minio_s3_traffic_received_bytes`             | Total number of s3 bytes received.                       |