if err != nil {
			t.Errorf("Test %d: Expected to pass but failed. %s", i+1, err)
		}
		if err == nil && s != testCase.expectedSize {
			t.Errorf("Test %d: The calculated part size is incorrect: expected = %d, found = %d\n", i+1, testCase.expectedSize, s)
		}
	}

	testCasesFailure := []struct {
		totalSize int64
		partSize  int64
		partIndex int
		err       error
	}{

    }

    @Test
    @DisplayName("size should return correct message size")
    void testSize() {
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 24;
        // size8 method rounds up to 8-byte boundary
        int expectedAlignedSize = (expectedSize + 7) & ~7;

        assertEquals(expectedAlignedSize, request.size());
    }

    @Test

        // When
        int size = req.size();

        // Then
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 24 + token.length;
        int alignedSize = (expectedSize + 7) & ~7; // size8 alignment
        assertEquals(alignedSize, size);
    }

    @Test
    @DisplayName("Should calculate correct message size without token")

  }

  public static <K, V> Builder<K, V> builder() {
    return new Builder<K, V>();
  }

  public static <K, V> Builder<K, V> builderWithExpectedSize(int expectedSize) {
    return new Builder<K, V>(expectedSize);
  }

  static <K, V> Entry<K, V> entryOf(K key, V value) {
    checkEntryNotNull(key, value);
    return Maps.immutableEntry(key, value);
  }

        void testSizeCalculation(int[] ciphers, int expectedSize) {
            // Arrange
            context = new EncryptionNegotiateContext(mockConfig, ciphers);

            // Act
            int size = context.size();

            // Assert
            assertEquals(expectedSize, size);
        }

        static Stream<Arguments> provideCipherArrays() {

   * @throws ClassCastException if a data element has the wrong type
   */
  protected abstract Table<String, Integer, C> create(@Nullable Object... data);

  protected void assertSize(int expectedSize) {
    assertEquals(expectedSize, table.size());
  }

  @Override
  public void setUp() throws Exception {
    super.setUp();
    table = create();
  }

  public void testContains() {

   * @since 23.1
   */
  public static <K, V> Builder<K, V> builderWithExpectedSize(int expectedSize) {
    checkNonnegative(expectedSize, "expectedSize");
    return new Builder<>(expectedSize);
  }

  static void checkNoConflict(
      boolean safe, String conflictDescription, Object entry1, Object entry2) {
    if (!safe) {
      throw conflictException(conflictDescription, entry1, entry2);
    }
  }

        int size = request.size();

        // Then
        // Size should be aligned to 8 bytes: SMB2_HEADER_LENGTH + 4 bytes for cancel structure
        int expectedSize = ((Smb2Constants.SMB2_HEADER_LENGTH + 4 + 7) / 8) * 8;
        assertEquals(expectedSize, size, "Size calculation should be correct and 8-byte aligned");
    }

    @Test
    @DisplayName("Test writeBytesWireFormat writes correct bytes")

    return unsafeDelegateList(list);
  }

  public static <E> Builder<E> builder() {
    return new Builder<E>();
  }

  public static <E> Builder<E> builderWithExpectedSize(int expectedSize) {
    return new Builder<E>(expectedSize);
  }

  public static final class Builder<E> extends ImmutableCollection.Builder<E> {
    private final ArrayList<E> contents;

    public Builder() {

    }

    @Test
    @DisplayName("size should return correct message size")
    void testSize() {
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 24;
        // size8 method rounds up to 8-byte boundary
        int expectedAlignedSize = (expectedSize + 7) & ~7;

        assertEquals(expectedAlignedSize, request.size());
    }

    @Test