}

        @ParameterizedTest
        @DisplayName("Should handle various remaining bytes values")
        @ValueSource(ints = { 0, 1, 512, 1024, 4096, 65536, Integer.MAX_VALUE })
        void testVariousRemainingBytes(int remaining) {
            assertDoesNotThrow(() -> request.setRemainingBytes(remaining));
        }
    }

    @Nested
    @DisplayName("Size Calculation Tests")

      int remaining;
      @Nullable E element;

      @Override
      public boolean hasNext() {
        return (remaining > 0) || entryIterator.hasNext();
      }

      @Override
      public E next() {
        if (remaining <= 0) {
          Entry<E> entry = entryIterator.next();
          element = entry.getElement();
          remaining = entry.getCount();
        }

            assertEquals("Hello", new String(buffer, 0, bytesRead, "UTF-8"));

            // Read remaining bytes
            byte[] remaining = new byte[20];
            int remainingBytes = stream.read(remaining);
            assertEquals(8, remainingBytes); // ", World!"
            assertEquals(", World!", new String(remaining, 0, remainingBytes, "UTF-8"));
        }
    }

    // --- isInMemory() tests ---

            // Parse SMB URL manually
            String remaining = urlStr.substring(6); // Remove "smb://"
            int slashIndex = remaining.indexOf('/');
            if (slashIndex == -1) {
                this.host = remaining;
                this.path = "/";
            } else {
                this.host = remaining.substring(0, slashIndex);
                this.path = remaining.substring(slashIndex);
            }

        bulkDelete.execute().actionGet(fessConfig.getIndexSearchTimeout());

        // Delete any remaining events beyond the search size limit (discard overflow)
        try {
            client.deleteByQuery(indexName, QueryBuilders.termQuery("hostname", hostname));
        } catch (final Exception e) {
            logger.debug("Failed to delete remaining log notifications.", e);
        }

    @Nullable Node<K, V> next;
    @Nullable Node<K, V> toRemove;
    int expectedModCount;
    int remaining;

    BiIterator(HashBiMap<K, V> biMap) {
      this.biMap = biMap;
      next = biMap.firstInKeyInsertionOrder;
      expectedModCount = biMap.modCount;
      remaining = biMap.size();
    }

    @Override
    public final boolean hasNext() {

            assertDoesNotThrow(() -> request.setMinimumCount(512));
            assertDoesNotThrow(() -> request.setMinimumCount(Integer.MAX_VALUE));
        }

        @Test
        @DisplayName("Should set remaining bytes correctly")
        void testSetRemainingBytes() {
            assertDoesNotThrow(() -> request.setRemainingBytes(0));
            assertDoesNotThrow(() -> request.setRemainingBytes(1024));

            }

            if (totalChars + docEntry.length() > maxChars) {
                final int remaining = maxChars - totalChars - CONTEXT_TRUNCATION_BUFFER;
                if (remaining > 0 && docEntry.length() > remaining) {
                    docEntry.setLength(remaining);
                    docEntry.append("...\n\n");
                    documentContent.append(docEntry);
                }

	if totalSize == 0 {
		return 0, nil
	}

	var written int64
	for {
		buf := alignedBuf
		if totalSize > 0 {
			remaining := totalSize - written
			if remaining < int64(len(buf)) {
				buf = buf[:remaining]
			}
		}

		nr, err := io.ReadFull(r, buf)
		eof := errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF)
		if err != nil && !eof {

      int remaining = queue.size();
      while (queueIterator.hasNext()) {
        Integer element = queueIterator.next();
        remaining--;
        assertThat(elements).contains(element);
        if (random.nextBoolean()) {
          elements.remove(element);
          queueIterator.remove();
        }
      }
      assertThat(remaining).isEqualTo(0);
      assertIntact(queue);