}

.user .avatar-wrapper img {
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
}

.user .title {
  text-align: center;
}

.user .count {
  font-size: 80%;
  text-align: center;
}

a.announce-link:link,
a.announce-link:visited {
  color: #fff;
}

a.announce-link:hover {
  color: var(--md-accent-fg-color);
}

.announce-wrapper {

        count,
        getMultiset().count(element));

    int size = 0;
    for (Multiset.Entry<E> entry : getMultiset().entrySet()) {
      size += entry.getCount();
    }
    assertEquals(
        "multiset.size() should be the sum of the counts of all entries",
        size,
        getMultiset().size());
  }

  /** Call the {@code setCount()} method under test, and check its return value. */

        // (shallow copy behavior)
        assertEquals("modified", result.getDocumentList().get(0).get("id"));

        // Document list size should remain the same
        assertEquals(1, result.getDocumentList().size());
    }

    public void test_multipleBuilds() {
        // Test that each builder creates independent results
        // Create first result with one document

    @DisplayName("Should handle various data sizes in hexdump")
    void testHexdumpVariousSizes(int size) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(baos);

        byte[] data = createTestData(size);
        Hexdump.hexdump(ps, data, 0, size);
        String output = baos.toString();

        assertNotNull(output);

    }

    @Test
    @DisplayName("Should calculate correct size")
    void testSize() {
        // When
        int size = request.size();

        // Then
        // Size should be aligned to 8 bytes: SMB2_HEADER_LENGTH + 32
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 32;
        // The size8 method aligns to 8-byte boundary
        int alignedSize = (expectedSize + 7) & ~7;

        if (stopwordsItemList == null) {
            reload(null);
        }

        if (offset >= stopwordsItemList.size() || offset < 0) {
            return new PagingList<>(Collections.<StopwordsItem> emptyList(), offset, size, stopwordsItemList.size());
        }

        int toIndex = offset + size;
        if (toIndex > stopwordsItemList.size()) {

  private var contentLength = -1L

  @get:JvmName("boundary")
  val boundary: String
    get() = boundaryByteString.utf8()

  /** The number of parts in this multipart body. */
  @get:JvmName("size")
  val size: Int
    get() = parts.size

  fun part(index: Int): Part = parts[index]

  override fun isOneShot(): Boolean = parts.any { it.body.isOneShot() }

  /** A combination of [type] and [boundaryByteString]. */

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

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

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

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

		offset := ei.V2Obj.EcBSize * blockNum
		if offset >= m.size {
			return nil, fmt.Errorf("block %d out of range. offset %d > size %d", blockNum, offset, m.size)
		}
		m.blockOffset = offset
		m.blocks = (m.size + ei.V2Obj.EcBSize - 1) / ei.V2Obj.EcBSize
		if m.blocks > 0 {
			m.blocks--
		}
		if blockNum < m.blocks {
			m.size = ei.V2Obj.EcBSize
		} else {
			m.size -= offset
		}

		b, err := os.ReadFile(file)

			sizeS.failedCount++
		case replication.Completed, replication.CompletedLegacy:
			tgtSizeS.replicatedSize += oi.Size
			tgtSizeS.replicatedCount++
			sizeS.replicatedSize += oi.Size
			sizeS.replicatedCount++
		}
		sizeS.replTargetStats[arn] = tgtSizeS
	}

	if oi.ReplicationStatus == replication.Replica {
		sizeS.replicaSize += oi.Size
		sizeS.replicaCount++
	}
}