}
					//  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.

      return this;
    }

    @CanIgnoreReturnValue
    Builder<K, V> combine(Builder<K, V> other) {
      checkNotNull(other);
      ensureCapacity(this.size + other.size);
      arraycopy(other.entries, 0, this.entries, this.size, other.size);
      this.size += other.size;
      return this;
    }

    private ImmutableMap<K, V> build(boolean throwIfDuplicateKeys) {
      /*

    }

    /**
     * Returns the page size.
     *
     * @return The page size.
     */
    public int getPageSize() {
        if (pageSize <= 0) {
            pageSize = getDefaultPageSize();
        }
        return pageSize;
    }

    /**
     * Sets the page size.
     *
     * @param pageSize The page size.
     */
    public void setPageSize(final int pageSize) {

    assertThat(body.contentType().toString())
      .isEqualTo("multipart/mixed; boundary=123")
    assertThat(body.parts.size).isEqualTo(1)
    assertThat(body.contentLength()).isEqualTo(33L)
    val buffer = Buffer()
    body.writeTo(buffer)
    assertThat(body.contentLength()).isEqualTo(buffer.size)
    assertThat(buffer.readUtf8()).isEqualTo(expected)
  }

  @Test
  fun threeParts() {
    val expected =
      """

        }
    }

    @Nested
    @DisplayName("Size Method Tests")
    class SizeTests {

        @Test
        @DisplayName("Should return correct size of 24 bytes")
        void testSize() {
            // Given
            SrvCopychunk chunk = new SrvCopychunk(0, 0, 0);

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

            // Then
            assertEquals(EXPECTED_SIZE, size);

      return ImmutableList.of();
    }
    int[] stripes = new int[result.size()];
    for (int i = 0; i < result.size(); i++) {
      stripes[i] = indexFor(result.get(i));
    }
    Arrays.sort(stripes);
    // optimize for runs of identical stripes
    int previousStripe = stripes[0];
    result.set(0, getAt(previousStripe));
    for (int i = 1; i < result.size(); i++) {
      int currentStripe = stripes[i];

     * This is a required field with a maximum length of 1000 characters.
     */
    @Required
    @Size(max = 1000)
    public String name;

    /**
     * The actual access token string.
     * This is the token value that will be used for authentication.
     * Maximum length is 10000 characters.
     */
    @Size(max = 10000)
    public String token;

    /**
     * The permissions associated with this access token.

		{Name: "INT", DBName: "fint", BindNames: []string{"INT"}, DataType: schema.Int, Creatable: true, Updatable: true, Readable: true, Size: 64, Tag: `gorm:"column:fint"`},
		{Name: "INT8", DBName: "fint8", BindNames: []string{"INT8"}, DataType: schema.Int, Creatable: true, Updatable: true, Readable: true, Size: 8, Tag: `gorm:"column:fint8"`},

            }
            response = r;

            executeCallbacks = new ArrayList<>(doneCallbacks.size());
            Consumer<RESPONSE> callback;
            while ((callback = doneCallbacks.poll()) != null) {
                executeCallbacks.add(callback);
            }
        }
        if (executeCallbacks.size() > 0) {
            try {
                executeCallbacks.stream().forEach(callback -> callback.accept(response));

  public void testElementSetRemovePropagatesToMultiset() {
    Set<E> elementSet = getMultiset().elementSet();
    int size = getNumElements();
    int expectedSize = size - getMultiset().count(e0());
    assertTrue(elementSet.remove(e0()));
    assertFalse(getMultiset().contains(e0()));
    assertEquals(expectedSize, getMultiset().size());
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_REMOVE)