t.Errorf("Expected md5base64 \"4vxxTEcn7pOV8yTNLn8zHw==\", got \"%s\"", base64.StdEncoding.EncodeToString(md5sum))
	}
	if r.Size() != 4 {
		t.Errorf("Expected size 4, got %d", r.Size())
	}
	if r.ActualSize() != 4 {
		t.Errorf("Expected size 4, got %d", r.ActualSize())
	}
	expectedMD5, err := hex.DecodeString("e2fc714c4727ee9395f324cd2e7f331f")
	if err != nil {
		t.Fatal(err)
	}

    int size = multimap().size();
    List<V> oldValues = new ArrayList<>(multimap().get(k0()));
    List<V> values = asList(v0(), v3(), v0());
    assertEquals(oldValues, new ArrayList<V>(multimap().replaceValues(k0(), values)));
    assertEquals(size - oldValues.size() + multimap().get(k0()).size(), multimap().size());
    assertTrue(multimap().get(k0()).containsAll(values));
  }

  @CollectionSize.Require(absent = ZERO)

            )

        assertTrue(buckets.size == 5)
        assertEquals("LargeSubprojectSplit(subproject=Subproject(name=a, size=20), split=1)", buckets[0].toString())
        assertEquals("LargeSubprojectSplit(subproject=Subproject(name=b, size=19), split=1)", buckets[1].toString())
        assertEquals(
            "SmallSubprojectCombination(subprojects=[Subproject(name=c, size=5), Subproject(name=j, size=4), Subproject(name=i, size=4)])",

)

func TestSizeHistogramToMap(t *testing.T) {
	tests := []struct {
		sizes []int64
		want  map[string]uint64
	}{
		{
			sizes: []int64{100, 1000, 72_000, 100_000},
			want: map[string]uint64{
				"LESS_THAN_1024_B":         2,
				"BETWEEN_64_KB_AND_256_KB": 2,
				"BETWEEN_1024B_AND_1_MB":   2,
			},
		},
		{
			sizes: []int64{100, 1000, 2000, 100_000, 13 * humanize.MiByte},
			want: map[string]uint64{

app = FastAPI()

items = {"foo": {"name": "Fighters", "size": 6}, "bar": {"name": "Tenders", "size": 3}}


@app.put("/items/{item_id}")
async def upsert_item(
    item_id: str,
    name: str | None = Body(default=None),
    size: int | None = Body(default=None),
):
    if item_id in items:
        item = items[item_id]
        item["name"] = name
        item["size"] = size
        return item
    else:

    }

    /**
     * Get the maximum size for RDMA read/write operations
     *
     * @return maximum read/write size in bytes
     */
    public int getMaxReadWriteSize() {
        return maxReadWriteSize;
    }

    /**
     * Set the maximum size for RDMA read/write operations
     *
     * @param maxReadWriteSize maximum read/write size in bytes
     */

                CollectSpliterators.flatMap(
                    Arrays.spliterator(new String[] {"abc", "", "de", "f", "g", ""}),
                    (String str) -> charactersOf(str).spliterator(),
                    Spliterator.SIZED | Spliterator.DISTINCT | Spliterator.NONNULL,
                    7))
        .expect('a', 'b', 'c', 'd', 'e', 'f', 'g');
  }

  public void testFlatMap_nullStream() {
    SpliteratorTester.of(
            () ->

            return Stream.of(Arguments.of(null, 4), // size() returns 4 even with null
                    Arguments.of(new int[0], 4), // size() returns 4 for empty array
                    Arguments.of(new int[] { 1 }, 4 + 2), // size() returns 4 + 2*1
                    Arguments.of(new int[] { 1, 2 }, 4 + 4), // size() returns 4 + 2*2
                    Arguments.of(new int[] { 1, 2, 3, 4, 5 }, 4 + 10) // size() returns 4 + 2*5
            );
        }

        String pipeName = "TestPipe";
        FsctlPipeWaitRequest request = new FsctlPipeWaitRequest(pipeName);

        // Verify size calculation
        int expectedSize = 14 + pipeName.getBytes(StandardCharsets.UTF_16LE).length;
        assertEquals(expectedSize, request.size());
    }

    @Test
    @DisplayName("Test constructor with name and timeout sets correct fields")
    void testConstructorWithNameAndTimeout() {

	// Fill the pool beyond the capped pool size.
	for i := uint64(0); i < size*2; i++ {
		bp.Put(make([]byte, bp.w, bp.wcap))
	}

	b = bp.Get()
	if len(b) != width {
		t.Fatalf("bytepool length invalid: got %v want %v", len(b), width)
	}
	if cap(b) != capWidth {
		t.Fatalf("bytepool length invalid: got %v want %v", cap(b), capWidth)
	}

	bp.Put(b)

	// Check the size of the pool.
	if uint64(len(bp.c)) != size {