for (int size = 1; size < 200; size++) {
      assertWontGrow(
          size,
          new LinkedHashMap<>(),
          Maps.newLinkedHashMapWithExpectedSize(size),
          Maps.newLinkedHashMapWithExpectedSize(size));
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  private static void assertWontGrow(
      int size,
      HashMap<Object, Object> referenceMap,

				// Skip transitioned objects for now. TBD
				if version.IsRemote() {
					stopFn(version.Size, errors.New("ILM Tiered version will be skipped for now"))
					continue
				}

				// Apply lifecycle rules on the objects that are expired.
				if filterLifecycle(bucket, version.Name, version) {
					expired++
					stopFn(version.Size, errors.New("ILM expired object/version will be skipped"))
					continue
				}

 *
 * @param list the list to split, must be ordered by size desc
 * @param toIntFunction the function used to map the element to its "size"
 * @param largeElementSplitFunction the function used to further split the large element into smaller pieces
 * @param smallElementAggregateFunction the function used to aggregate tiny elements into a large bucket
 * @param expectedBucketNumber the return value's size should be expectedBucketNumber
 */

    /**
     * Gets the maximum buffer size for IO operations
     *
     * @return the maximum size of IO buffers, limits the maximum message size
     */
    int getMaximumBufferSize();

    /**
     *
     * Property {@code jcifs.smb.client.transaction_buf_size} (int, default 65535)
     *
     * @return maximum data size for SMB transactions
     */
    int getTransactionBufferSize();

        final List<Pattern> excludePatterns = urlFilterService.getExcludeUrlPatternList(sessionId);

        assertEquals(1, includePatterns.size());
        assertEquals(1, excludePatterns.size());

        // Verify patterns work correctly
        assertTrue(includePatterns.get(0).matcher("http://example.com/page").matches());

  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)

                    artifact.getDependencyTrail()));
        }

        buffer.append("----------").append(LS);

        int size = artifacts.size();

        buffer.append(size).append(" required artifact");

        if (size > 1) {
            buffer.append("s are");
        } else {
            buffer.append(" is");
        }

   * a size of 0 despite actually having content when read).
   *
   * <p>In either case, for mutable sources such as files, a subsequent read may return a different
   * number of bytes if the contents are changed.
   *
   * @throws IOException if an I/O error occurs while reading the size of this source
   */
  public long size() throws IOException {

        }

        public void setTestResponse(TestServerMessageBlock2Response response) {
            this.testResponse = response;
        }

        public void setTestSize(int size) {
            this.testSize = size;
        }

        public void setTestLength(int length) {
            this.testEncodedLength = length;
        }

        @Override

        when(dataHelper.getUrlQueueList(sessionId)).thenReturn(mockQueue);

        // Execute
        service.add(sessionId, url);

        // Verify
        assertEquals(1, mockQueue.size());
        UrlQueueImpl<Long> added = mockQueue.peek();
        assertNotNull(added);
        assertEquals(sessionId, added.getSessionId());
        assertEquals(url, added.getUrl());