assertEquals(16, bytesRead); // Structure size + reserved (4) + count (4) + remaining (4) + channel info (4)
            assertEquals(1024, response.getCount());
            assertEquals(512, response.getRemaining());
        }

        @Test
        @DisplayName("Should throw exception for invalid structure size")
        void testInvalidStructureSize() {
            byte[] buffer = new byte[64];

rep_obj3_etag=$(echo "${stat_out3_rep}" | jq '.etag')
rep_obj3_size=$(echo "${stat_out3_rep}" | jq '.size')
rep_obj3_md5=$(echo "${stat_out3_rep}" | jq '.metadata."X-Amz-Server-Side-Encryption-Customer-Key-Md5"')

# Check the etag and size of replicated SSEC objects
if [ "${rep_obj1_etag}" != "${src_obj1_etag}" ]; then

	directoryEndLen          = 22         // + comment
	dataDescriptorLen        = 16         // four uint32: descriptor signature, crc32, compressed size, size
	dataDescriptor64Len      = 24         // two uint32: signature, crc32 | two uint64: compressed size, size
	directory64LocLen        = 20         //
	directory64EndLen        = 56         // + extra

	// Constants for the first byte in CreatorVersion.
	creatorFAT    = 0

					}
					//  Asserting the Size in the PartInfo.
					if actualMetaData.Size != expectedResult.Parts[j].Size {
						t.Errorf("Test %d: %s: Part %d: Expected Part Size to be \"%d\", but instead found \"%d\"", i+1, instanceType, j+1, expectedResult.Parts[j].Size, actualMetaData.Size)
					}
					//  Asserting the ETag in the PartInfo.

    }
  }

  @Override
  int distinctElements() {
    return distinctElements;
  }

  @Override
  public int size() {
    return Ints.saturatedCast(size);
  }

  @Override
  public int count(@Nullable Object element) {
    // isActuallyE checks for null, but we check explicitly to help nullness checkers.

    }

    @Test
    @DisplayName("Test size calculation with short filename")
    void testSizeWithShortFilename() {
        FileRenameInformation2 info = new FileRenameInformation2("test.txt", false);
        // 20 bytes fixed + 2 * 8 chars = 20 + 16 = 36
        assertEquals(36, info.size());
    }

    @Test
    @DisplayName("Test size calculation with long filename")
    void testSizeWithLongFilename() {

  @BeforeExperiment
  void setUp() {
    testBytesA = new byte[size];
    random.nextBytes(testBytesA);
    testBytesB = Arrays.copyOf(testBytesA, size);
    int indexToDifferAt = -1;
    switch (whereToDiffer) {
      case ONE_PERCENT_IN:
        indexToDifferAt = (int) (size * 0.01);
        break;
      case LAST_BYTE:
        indexToDifferAt = size - 1;
        break;
      case NOT_AT_ALL:
    }

        logger.debug("Setting up test: {}", getClass().getSimpleName());
    }

    /**
     * Create a test byte array with specified size and pattern
     */
    protected byte[] createTestData(int size) {
        byte[] data = new byte[size];
        for (int i = 0; i < size; i++) {
            data[i] = (byte) (i % 256);
        }
        return data;
    }

    /**

    int size = stream.readInt();
    populateMap(map, stream, size);
  }

  /**
   * Populates a map by reading an input stream, as part of deserialization. See {@link #writeMap}
   * for the data format.
   */
  static <K extends @Nullable Object, V extends @Nullable Object> void populateMap(
      Map<K, V> map, ObjectInputStream stream, int size)
      throws IOException, ClassNotFoundException {

    assertEquals(underlying.size(), map.size());

    underlying.put("d", 4);
    assertEquals(underlying.size(), map.size());
    assertThat(map.get("d")).isEqualTo("4");

    underlying.remove("c");
    assertEquals(underlying.size(), map.size());
    assertFalse(map.containsKey("c"));

    underlying.clear();
    assertEquals(underlying.size(), map.size());
  }