edge-case regression introduced with the events cleanup in 3.14.0.

 *  Fix: Provide actionable advice when the exchange is non-null. Prior to 3.14, OkHttp would
    silently leak connections when an interceptor retries without closing the response body. With
    3.14 we detect this problem but the exception was not helpful.

## Version 3.14.0

_2019-03-14_

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;

/**
 * Test to verify that repositories from one project don't leak to sibling projects.
 */
@PlexusTest
public class RepositoryLeakageTest extends AbstractMavenProjectTestCase {

    @Test
    @SuppressWarnings("checkstyle:MethodLength")

  }

  private static boolean isWindows() {
    return OS_NAME.value().startsWith("Windows");
  }

  /**
   * Test that verifies the resource leak fix for <a
   * href="https://github.com/google/guava/issues/5756">Issue #5756</a>.
   *
   * <p>This test covers a scenario where we write a smaller amount of data first, then write a

			metric.LastOnline = epHealth.lastOnline
			metric.Online = epHealth.Online
			metric.Latency = madmin.LatencyStat{
				Curr: epHealth.latency.curr,
				Avg:  epHealth.latency.avg,
				Max:  epHealth.latency.peak,
			}
		}
		m[dID] = metric
	}
	return m
}

func (srs *SRStatus) updateXferRate(sz int64, duration time.Duration) {
	if sz > minLargeObjSize {
		srs.XferRateLrg.addSize(sz, duration)

            fail("Should have thrown RuntimeException");
        } catch (RuntimeException e) {
            assertEquals("Simulated processing error", e.getMessage());
            // If InputStream wasn't properly closed, this would leak resources
            // try-with-resources ensures cleanup happens
        } catch (IOException e) {
            fail("Should not throw IOException: " + e.getMessage());
        }
    }

    /**

 * Fix: Use strict timeouts when aborting a download.
 * Fix: Support Shoutcast HTTP responses like `ICY 200 OK`.
 * Fix: Don't unzip if there isn't a response body.
 * Fix: Don't leak gzip streams on redirects.
 * Fix: Don't do DNS lookups on invalid hosts.
 * Fix: Exhaust the underlying stream when reading gzip streams.
 * Fix: Support the `PATCH` method.
 * Fix: Support request bodies on `DELETE` method.

    allocateAndLeakAllocation(poolApi, c1)
    awaitGarbageCollection()
    assertThat(pool.closeConnections(100L)).isEqualTo(0L)
    assertThat(c1.calls).isEmpty()

    // Can't allocate once a leak has been detected.
    assertThat(c1.noNewExchanges).isTrue()
  }

  @Test fun interruptStopsThread() {
    val taskRunnerThreads = mutableListOf<Thread>()
    val taskRunner =
      TaskRunner(

          if (taskFuture.isDone()) {
            // Since the value of oldFuture can only ever be immediateVoidFuture() or setFuture of a
            // future that eventually came from immediateVoidFuture(), this doesn't leak throwables
            // or completion values.
            newFuture.setFuture(oldFuture);
          } else if (outputFuture.isCancelled() && taskExecutor.trySetCancelled()) {

  }

  /**
   * Prunes any leaked calls and then returns the number of remaining live calls on [connection].
   * Calls are leaked if the connection is tracking them but the application code has abandoned
   * them. Leak detection is imprecise and relies on garbage collection.
   */
  private fun pruneAndGetAllocationCount(
    connection: RealConnection,
    now: Long,
  ): Int {
    connection.assertLockHeld()

    }

    var networkResponse: Response? = null
    try {
      networkResponse = chain.proceed(networkRequest)
    } finally {
      // If we're crashing on I/O or otherwise, don't leak the cache body.
      if (networkResponse == null && cacheCandidate != null) {
        cacheCandidate.body.closeQuietly()
      }
    }

    // If we have a cache response too, then we're doing a conditional get.