}

  @Throws(IOException::class)
  private fun readPriority(
    handler: Handler,
    length: Int,
    flags: Int,
    streamId: Int,
  ) {
    if (length != 5) throw IOException("TYPE_PRIORITY length: $length != 5")
    if (streamId == 0) throw IOException("TYPE_PRIORITY streamId == 0")
    readPriority(handler, streamId)
  }

  @Throws(IOException::class)
  private fun readPriority(
    handler: Handler,

        this.bytesReceived += byteCount
      } catch (e: IOException) {
        throw complete(e)
      }
    }

    @Throws(IOException::class)
    override fun flush() {
      try {
        super.flush()
      } catch (e: IOException) {
        throw complete(e)
      }
    }

    @Throws(IOException::class)
    override fun close() {
      if (closed) return

        } catch (IOException ex) { }
        return connection.getHeaderField(index);
    }

    public Object getContent() throws IOException {
        try {
            handshake();
        } catch (IOException ex) { }
        return connection.getContent();
    }

    public Object getContent(Class[] classes) throws IOException {
        try {
            handshake();
        } catch (IOException ex) { }

                throws IOException {
              Files.deleteIfExists(file);
              return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc)
                throws IOException {
              if (exc != null) {
                return FileVisitResult.TERMINATE;

    if (expectedLines.isEmpty()) {
      assertNull(source.readFirstLine());
    } else {
      assertEquals(expectedLines.get(0), source.readFirstLine());
    }
  }

  public void testReadLines_toList() throws IOException {
    assertExpectedLines(source.readLines());
  }

  public void testIsEmpty() throws IOException {
    assertEquals(expected.isEmpty(), source.isEmpty());
  }

    closed = true;
    throwIf(CLOSE_THROWS);
    in.close();
  }

  private void throwIf(TestOption option) throws IOException {
    throwIf(options.contains(option));
  }

  private static void throwIf(boolean condition) throws IOException {
    if (condition) {
      throw new IOException();
    }
  }

            return out;
          }
        });
    assertExpectedBytes(out.toByteArray());
  }

  public void testIsEmpty() throws IOException {
    assertEquals(expected.length == 0, source.isEmpty());
  }

  public void testSize() throws IOException {
    assertEquals(expected.length, source.size());
  }

  public void testSizeIfKnown() throws IOException {

  }

  public void testOpenBufferedStream() throws IOException {
    Writer writer = sink.openBufferedStream();
    assertTrue(sink.wasStreamOpened());
    assertFalse(sink.wasStreamClosed());

    writer.write(STRING);
    writer.close();

    assertTrue(sink.wasStreamClosed());
    assertEquals(STRING, sink.getString());
  }

  public void testWrite_string() throws IOException {
    assertEquals("", sink.getString());

  }

  public void testCopyTo_outputStream() throws IOException {
    ByteArrayOutputStream out = new ByteArrayOutputStream();

    assertEquals(bytes.length, source.copyTo(out));
    assertTrue(source.wasStreamOpened() && source.wasStreamClosed());

    assertArrayEquals(bytes, out.toByteArray());
  }

  public void testCopyTo_byteSink() throws IOException {
    TestByteSink sink = new TestByteSink();

    throwIf(closed);
    throwIf(WRITE_THROWS);
    super.write(b);
  }

  @Override
  public void close() throws IOException {
    closed = true;
    super.close();
    throwIf(CLOSE_THROWS);
  }

  private void throwIf(TestOption option) throws IOException {
    throwIf(options.contains(option));
  }

  private static void throwIf(boolean condition) throws IOException {