* identical functionality but do not throw {@link IOException}.
 *
 * <p><b>Warning:</b> The caller is responsible for not attempting to read past the end of the
 * array. If any method encounters the end of the array prematurely, it throws {@link
 * IllegalStateException} to signify <i>programmer error</i>. This behavior is a technical violation
 * of the supertype's contract, which specifies a checked exception.
 *
 * @author Kevin Bourrillion

   *
   * If the response body was successfully read until the end, this is the headers that followed,
   * or empty headers if there were none that followed.
   *
   * If the response body was closed prematurely or failed with an error, this will be the sentinel
   * value [TRAILERS_RESPONSE_BODY_TRUNCATED]. In that case attempts to read the trailers should not
   * return the value but instead throw an exception.
   */

    MinMaxPriorityQueue<Integer> mmHeap = MinMaxPriorityQueue.create();
    mmHeap.addAll(Lists.newArrayList(1, 2));
    Iterator<Integer> it = mmHeap.iterator();
    assertTrue("Iterator has reached end prematurely", it.hasNext());
    it.next();
    it.next();
    assertThrows(NoSuchElementException.class, () -> it.next());
  }

  public void testIteratorConcurrentModification() {

      }
    }
    connection.writePing()
    connection.shutdown(ErrorCode.PROTOCOL_ERROR)
    assertThat(connection.openStreamCount()).isEqualTo(1)
    connection.awaitPong() // Prevent the peer from exiting prematurely.

    // Verify the peer received what was expected.
    val synStream1 = peer.takeFrame()
    assertThat(synStream1.type).isEqualTo(Http2.TYPE_HEADERS)
    val pingFrame = peer.takeFrame()

- When initializing nodes using external cloud-providers, the process now waits for the providerID value to be available before declaring the node ready. This ensures that nodes are not marked as Ready prematurely due to communication errors with the cloud-provider. The providerID and zone labels are necessary for integrations such as load balancers to function correctly. Users can choose to opt out of this behavior by setting the feature flag OptionalProviderID...

        doReturn(-1).when(raf).read(any(byte[].class), anyInt(), eq(1));
        assertEquals(-1, raf.read());
    }

    @Test
    @DisplayName("readFully(): throws SmbEndOfFileException on premature EOF")
    void readFully_throws_onEOF() throws Exception {
        SmbRandomAccessFile raf = spy(newInstance("r", false, false, false));
        doReturn(-1).when(raf).read(any(byte[].class), anyInt(), anyInt());

      // treats an incomplete response body as a ProtocolException.
    } catch (ioe: IOException) {
      // Change in https://bugs.openjdk.org/browse/JDK-8335135
      assertThat(ioe.message).isEqualTo("Premature EOF")
    }
  }

  private fun headersToList(response: MockResponse): List<String> {
    val headers = response.headers
    val size = headers.size
    val headerList: MutableList<String> = ArrayList(size)

      // treats an incomplete response body as a ProtocolException.
    } catch (ioe: IOException) {
      // Change in https://bugs.openjdk.org/browse/JDK-8335135
      assertThat(ioe.message).isEqualTo("Premature EOF")
    }
  }

  private fun headersToList(response: MockResponse.Builder): List<String> {
    val headers = response.build().headers
    return headers.map { (key, value) -> "$key: $value" }.toList()
  }

  }

  @Test
  fun serverDisconnectsPrematurelyWithNoLengthHeaders() {
    // Intentionally empty. This case doesn't make sense because there's no
    // such thing as a premature disconnect when the disconnect itself
    // indicates the end of the data stream.
  }

  private fun testServerPrematureDisconnect(transferKind: TransferKind) {
    val mockResponse = MockResponse.Builder()