assertEquals(result1.size(), result2.size());
        assertEquals(result2.size(), result3.size());

        for (int i = 0; i < result1.size(); i++) {
            assertEquals(result1.get(i), result2.get(i));
            assertEquals(result2.get(i), result3.get(i));
        }

        // Verify content is correct
        assertEquals(2, result1.size());

        Arrays.fill(dst, (byte) 0x55);

        // Act
        int written = enc.encode(dst, dstIndex);

        // Assert: reported written bytes matches size() and requested len.
        assertEquals(len, enc.size(), "size() must equal provided length");
        assertEquals(len, written, "encode() must return number of bytes written");

        // Assert: copied region equals the source slice.

			fr = &regFileReader{r, maker.size}
		case makeSparse:
			if !validateSparseEntries(maker.spd, maker.size) {
				t.Fatalf("invalid sparse map: %v", maker.spd)
			}
			sph := invertSparseEntries(maker.spd, maker.size)
			r := testNonEmptyReader{strings.NewReader(maker.makeReg.str)}
			fr = &regFileReader{r, maker.makeReg.size}
			fr = &sparseFileReader{fr, sph, 0}
		default:

        final int from;
        final int size;
        if (cb.isFetchScopeEffective()) {
            from = cb.getPageStartIndex();
            size = cb.getFetchSize();
        } else {
            from = 0;
            size = 10;
        }
        builder.setFrom(from);
        builder.setSize(size);
        final EsAbstractConditionBean esCb = (EsAbstractConditionBean) cb;

        Smb2TreeConnectRequest longReq = new Smb2TreeConnectRequest(mockConfig, longPath);

        // When
        int shortSize = shortReq.size();
        int longSize = longReq.size();

        // Then
        // SMB2_HEADER_LENGTH + 8 + path.length() * 2 (UTF-16LE)
        int expectedShortSize = Smb2Constants.SMB2_HEADER_LENGTH + 8 + shortPath.length() * 2;

        br.addElement(" in " + getClass().getSimpleName() + ".");
        br.addItem("Content Type");
        br.addElement(contentType);
        br.addItem("Boundary Size");
        br.addElement(boundarySize);
        br.addItem("Limit Size");
        br.addElement(limitSize);
        final String msg = br.buildExceptionMessage();

        context.setMaxCacheAge(45000L);
        context.setNotificationEnabled(true);
        context.setNotificationFilter(0x1F);

        byte[] buffer = new byte[context.size()];
        int bytesWritten = context.encode(buffer, 0);

        assertEquals(context.size(), bytesWritten);

        // Verify context header
        assertEquals(0, SMBUtil.readInt4(buffer, 0)); // Next

    assertEquals(1, getMap().size());
    assertTrue(getMap().containsKey(k0()));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(ONE)
  public void testForcePutValuePresent() {
    getMap().forcePut(k1(), v0());
    expectContents(mapEntry(k1(), v0()));
    assertEquals(k1(), getMap().inverse().get(v0()));
    assertEquals(1, getMap().size());
    assertFalse(getMap().containsKey(k0()));
  }

  // Represents how tightly we can pack things, as a maximum.
  private static final double DESIRED_LOAD_FACTOR = 0.5;

  /**
   * Returns an array size suitable for the backing array of a hash table that uses open addressing
   * with linear probing in its implementation. The returned size is the smallest power of two that
   * can hold setSize elements with the desired load factor.
   */
  @VisibleForTesting

    }

    @Test
    @DisplayName("Test size method")
    void testSize() {
        request = new Smb2SetInfoRequest(mockConfig);
        Encodable mockInfo = mock(Encodable.class);
        when(mockInfo.size()).thenReturn(100);
        request.setInfo(mockInfo);

        int size = request.size();

        // Expected size calculation: size8(SMB2_HEADER_LENGTH + 32 + info.size())