private final List<Long> sizes;

        private final List<String> ids;

        private final int hashCode;

        public CacheKey(List<Artifact> extensionArtifacts) {
            this.files = new ArrayList<>(extensionArtifacts.size());
            this.timestamps = new ArrayList<>(extensionArtifacts.size());
            this.sizes = new ArrayList<>(extensionArtifacts.size());

                }
                responseData.addMetaData(SMB_ALLOWED_SID_ENTRIES, sidAllowSet.toArray(new SID[sidAllowSet.size()]));
                responseData.addMetaData(SMB_DENIED_SID_ENTRIES, sidDenySet.toArray(new SID[sidDenySet.size()]));
            }
        } catch (final IOException e) {
            throw new CrawlingAccessException("Could not access " + file.getPath(), e);
        }

     *
     * @return initial security blob
     */
    public byte[] getSecurityBlob() {
        return this.securityBuffer;
    }

    /**
     * Gets the maximum transaction size supported by the server.
     *
     * @return the maxTransactSize
     */
    public int getMaxTransactSize() {
        return this.maxTransactSize;
    }

    /**
     * {@inheritDoc}
     *

	}

	// Fetch buffer for I/O, returns from the pool if not allocates a new one and returns.
	var buffer []byte
	switch size := data.Size(); {
	case size == 0:
		buffer = make([]byte, 1) // Allocate at least a byte to reach EOF
	case size >= fi.Erasure.BlockSize || size == -1:
		if int64(globalBytePoolCap.Load().Width()) < fi.Erasure.BlockSize {
			buffer = make([]byte, fi.Erasure.BlockSize, 2*fi.Erasure.BlockSize)

    List<Object> values = new ArrayList<>(map.values());
    assertThat(alternatingKeysAndValues).hasLength(2 * entries.size());
    assertThat(alternatingKeysAndValues).hasLength(2 * keys.size());
    assertThat(alternatingKeysAndValues).hasLength(2 * values.size());
    for (int i = 0; i < map.size(); i++) {
      Object expectedKey = alternatingKeysAndValues[2 * i];
      Object expectedValue = alternatingKeysAndValues[2 * i + 1];

      return cellIterator();
    }

    @Override
    public Spliterator<Cell<R, C, V>> spliterator() {
      return cellSpliterator();
    }

    @Override
    public int size() {
      return AbstractTable.this.size();
    }
  }

  @LazyInit private transient @Nullable Collection<V> values;

  @Override
  public Collection<V> values() {
    Collection<V> result = values;

        listen  [::]:9000;
        server_name  localhost;

        # To allow special characters in headers
        ignore_invalid_headers off;
        # Allow any size file to be uploaded.
        # Set to a value such as 1000m; to restrict file size to a specific value
        client_max_body_size 0;
        # To disable buffering
        proxy_buffering off;
        proxy_request_buffering off;

        location / {

    sort(entries, Helpers.entryComparator(navigableMap.comparator()));

    // some tests assume SEVERAL == 3
    if (entries.size() >= 1) {
      a = entries.get(0);
      if (entries.size() >= 3) {
        c = entries.get(2);
      }
    }
  }

  @CollectionSize.Require(ZERO)
  public void testEmptyMapFirst() {

    }

    @Test
    @DisplayName("Test size calculation")
    void testSize() {
        // Given
        Smb2CancelRequest request = new Smb2CancelRequest(mockConfig, 1L, 0L);

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

        // Then
        // Size should be aligned to 8 bytes: SMB2_HEADER_LENGTH + 4 bytes for cancel structure

            assertEquals(2, merged.processedPoms().size(), "Should merge all processed POMs");
            assertEquals(1, merged.modifiedPoms().size(), "Should only include successfully modified POMs");
            assertEquals(1, merged.errorPoms().size(), "Should include error POMs");
            assertTrue(merged.errorPoms().contains(pom2), "Should contain failed POM");
        }