assertThat(network.removeNode(nodeList.get(i))).isTrue();
      }

      assertThat(network.nodes()).isEmpty();
      assertThat(network.edges()).isEmpty(); // no edges can remain if there's no nodes
      AbstractNetworkTest.validateNetwork(network);

      Collections.shuffle(nodeList, gen);
      for (Integer node : nodeList) {
        assertThat(network.addNode(node)).isTrue();
      }

        assertThat(graph.removeNode(nodeList.get(i))).isTrue();
      }

      assertThat(graph.nodes()).isEmpty();
      assertThat(graph.edges()).isEmpty(); // no edges can remain if there's no nodes
      AbstractGraphTest.validateGraph(graph);

      Collections.shuffle(nodeList, gen);
      for (Integer node : nodeList) {
        assertThat(graph.addNode(node)).isTrue();
      }

    // Now process directly from the rest of the input buffer
    while (readBuffer.remaining() >= chunkSize) {
      process(readBuffer);
    }

    // Finally stick the remainder back in our usual buffer
    buffer.put(readBuffer);
    return this;
  }

  /*
   * Note: hashString(CharSequence, Charset) is intentionally not overridden.
   *

    // explicitly remove the existing value
    cache.asMap().computeIfPresent(1, (key, value) -> null);
    assertThat(notifications).hasSize(1);
    CacheTesting.checkEmpty(cache);

    // ensure no zombie entry remains
    cache.asMap().computeIfPresent(1, (key, value) -> null);
    assertThat(notifications).hasSize(1);
    CacheTesting.checkEmpty(cache);
  }

  public void testUpdates() {
    cache.put(key, "1");

            int written = resp.writeBytesWireFormat(buffer, index);

            // Assert
            assertEquals(0, written, "Should report 0 bytes written");
            assertArrayEquals(original, buffer, "Buffer must remain unchanged");
        }

        @Test
        @DisplayName("Handles null destination without throwing and returns 0")
        void allowsNullBuffer() {
            // Arrange

      if (closed) return

      if (bytesRemaining != 0L &&
        !discard(ExchangeCodec.DISCARD_STREAM_TIMEOUT_MILLIS, MILLISECONDS)
      ) {
        carrier.noNewExchanges() // Unread bytes remain on the stream.
        responseBodyComplete(TRAILERS_RESPONSE_BODY_TRUNCATED)
      }

      closed = true
    }
  }

  /** An HTTP body with alternating chunk sizes and chunk bodies. */

            assertEquals(pastExpiration, result.getExpiration());
            // toString should show negative remain time
            String str = result.toString();
            assertTrue(str.contains("remain="));
        }
    }

        // Session starts with usage count > 0, so acquire/release cycles maintain usage
        assertTrue(session.isInUse(), "Session should be in use initially");

        // Test acquire/release cycles (session remains in use due to initial transport acquire)
        for (int i = 0; i < 3; i++) {
            session.acquire();
            assertTrue(session.isInUse(), "Session should be in use after acquire " + i);

	if [[ $? -eq 0 ]]; then
		echo "Outputs are consistent."
		break
	fi

	remaining_attempts=$((max_wait_attempts - attempt))
	if ((attempt >= max_wait_attempts)); then
		echo "Outputs remain inconsistent after $max_wait_attempts attempts. Exiting with error."
		exit 1
	else
		echo "Outputs are inconsistent. Waiting for $wait_interval seconds (attempt $attempt/$max_wait_attempts)."
		sleep $wait_interval
	fi

            writeBytes.setAccessible(true);
            writeBytes.invoke(cancel, dst, 0);

            // Then - array should remain unchanged
            assertArrayEquals(originalDst, dst);
        }

        @Test
        @DisplayName("Read operations should not modify buffer array")