.testEquals();
  }

  private interface Loser<E extends Throwable> {
    void lose() throws E;
  }

  public <T extends Loser<AssertionError>> void testMethod_exceptionTypes()
      throws NoSuchMethodException {
    Method failMethod = Loser.class.getMethod("lose");
    Invokable<T, ?> invokable = new TypeToken<T>(getClass()) {}.method(failMethod);

        .testEquals();
  }

  private interface Loser<E extends Throwable> {
    void lose() throws E;
  }

  public <T extends Loser<AssertionError>> void testMethod_exceptionTypes()
      throws NoSuchMethodException {
    Method failMethod = Loser.class.getMethod("lose");
    Invokable<T, ?> invokable = new TypeToken<T>(getClass()) {}.method(failMethod);

    init {
      val source = snapshot.getSource(ENTRY_BODY)
      bodySource =
        object : ForwardingSource(source) {
          @Throws(IOException::class)
          override fun close() {
            snapshot.close()
            super.close()
          }
        }.buffer()
    }

    override fun contentType(): MediaType? = contentType?.toMediaTypeOrNull()

    assertThat(in1.exhausted()).isTrue()
    in1.close()
    assertThat(cache.writeSuccessCount()).isEqualTo(1)
    assertThat(cache.writeAbortCount()).isEqualTo(0)
    val response2 = client.newCall(request).execute()
    val in2 = response2.body.source()
    assertThat(in2.readUtf8("I love puppies but hate spiders".length.toLong()))
      .isEqualTo(
        "I love puppies but hate spiders",
      )

                            return new FileInputStream(testFile);
                        }

                        @Override
                        public void close() throws IOException {
                            // Nothing to close
                        }
                    };
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }

                            return new FileInputStream(testFile);
                        }

                        @Override
                        public void close() throws IOException {
                            // Nothing to close
                        }
                    };
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }

    checkNotClosed();
    if (target instanceof Flushable) {
      ((Flushable) target).flush();
    }
  }

  @Override
  public void close() throws IOException {
    this.closed = true;
    if (target instanceof Closeable) {
      ((Closeable) target).close();
    }
  }

  @Override
  public Writer append(char c) throws IOException {
    checkNotClosed();
    target.append(c);
    return this;

    return 0;
  }

  @Override
  public boolean ready() throws IOException {
    return (current != null) && current.ready();
  }

  @Override
  public void close() throws IOException {
    if (current != null) {
      try {
        current.close();
      } finally {
        current = null;
      }
    }
  }

                  return true;
                }
                return false;
              }
            },
            isParallel)
        .onClose(streamA::close)
        .onClose(streamB::close);
  }

  /**
   * Invokes {@code consumer} once for each pair of <i>corresponding</i> elements in {@code streamA}

            super.write(source, byteCount)
            totalBytesWritten += byteCount
            progressListener.update(totalBytesWritten, contentLength(), completed)
          }

          override fun close() {
            super.close()
            if (!completed) {
              completed = true
              progressListener.update(totalBytesWritten, contentLength(), completed)
            }
          }
        }