assertPermutationsCount(5040, Collections2.permutations(newArrayList(1, 2, 3, 4, 5, 6, 7)));
    assertPermutationsCount(40320, Collections2.permutations(newArrayList(1, 2, 3, 4, 5, 6, 7, 8)));
  }

  public void testPermutationSetSizeOverflow() {
    // 13 elements overflow an int
    assertEquals(
        Integer.MAX_VALUE,

		Parts:            nil,
		Erasure: ErasureInfo{
			Algorithm:    ReedSolomon.String(),
			DataBlocks:   4,
			ParityBlocks: 2,
			BlockSize:    10000,
			Index:        1,
			Distribution: []int{1, 2, 3, 4, 5, 6, 7, 8},
			Checksums: []ChecksumInfo{{
				PartNumber: 1,
				Algorithm:  HighwayHash256S,
				Hash:       nil,
			}},
		},
		MarkDeleted:      false,
		Data:             data,
		NumVersions:      1,

			},
		},
		Erasure: ErasureInfo{
			Algorithm:    ReedSolomon.String(),
			DataBlocks:   4,
			ParityBlocks: 2,
			BlockSize:    10000,
			Index:        1,
			Distribution: []int{1, 2, 3, 4, 5, 6, 7, 8},
			Checksums: []ChecksumInfo{
				{
					PartNumber: 1,
					Algorithm:  HighwayHash256S,
					Hash:       nil,
				},
				{
					PartNumber: 2,
					Algorithm:  HighwayHash256S,

    assertPermutationsCount(5040, Collections2.permutations(newArrayList(1, 2, 3, 4, 5, 6, 7)));
    assertPermutationsCount(40320, Collections2.permutations(newArrayList(1, 2, 3, 4, 5, 6, 7, 8)));
  }

  public void testPermutationSetSizeOverflow() {
    // 13 elements overflow an int
    assertEquals(
        Integer.MAX_VALUE,

        @ValueSource(strings = { "Simple ASCII", "Special chars: !@#$%^&*()", "Unicode: ñöt ascii ℃", "Mixed: ASCII + 中文 + Русский",
                "Emojis: 🎉🌟💻", "Very long string with multiple words and various characters 1234567890" })
        void testGetBytesWithVariousInputs(String input) {
            // When
            byte[] result = Strings.getBytes(input, StandardCharsets.UTF_8);

            // Then

// interface{} that holds the actual data
func (d *Decoder) any() (any, ValueType, error) {
	c := d.cur()

	switch c {
	case '"':
		i, err := d.string()
		return i, String, err
	case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
		i, err := d.number()
		return i, Number, err
	case '-':
		if c = d.next(); c < '0' || c > '9' {
			return nil, Unknown, d.mkError(ErrSyntax, "in negative numeric literal")
		}

        Proxy(Proxy.Type.HTTP, InetSocketAddress.createUnresolved("proxy.example.com", 1003)),
        InetSocketAddress(ipv4Address, 5678),
      ).toString(),
    ).isEqualTo("example.com:1003 via proxy 1.2.3.4:5678")
  }

  @Test fun routeToStringIpv6() {
    val ipv6Address =
      InetAddress.getByAddress(
        byteArrayOf(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1),
      )
    assertThat(

        assertEquals("operation", parsed.get("type"));
        assertEquals("reindex", parsed.get("name"));
        assertEquals("running", parsed.get("status"));
        assertEquals(1234567890, ((Number) parsed.get("createdTime")).longValue());
    }

    // ===================================================================================

		{"test-bucket-list-object", "", "", "", -1, resultCases[0], nil, true},
		// Testing for very large value of maxKey, this should set maxKeys to listObjectsLimit (20).
		{"test-bucket-list-object", "", "", "", 1234567890, resultCases[0], nil, true},
		// Testing for truncated value (21-24).
		{"test-bucket-list-object", "", "", "", 5, resultCases[1], nil, true},
		{"test-bucket-list-object", "", "", "", 4, resultCases[2], nil, true},

      prop(RetryDecision::retry).isFalse()
    }
  }

  @Test
  fun failedDribbledCallEventSequence() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("0123456789")
        .throttleBody(2, 100, TimeUnit.MILLISECONDS)
        .onResponseBody(CloseSocket())
        .build(),
    )
    client =
      client
        .newBuilder()