had a crash `IllegalArgumentException: Not a Conscrypt trust manager` because we depended on
    initialization order of companion objects.


## Version 4.7.1

_2020-05-18_

 *  Fix: Pass the right arguments in the trust manager created for `addInsecureHost()`. Without the
    fix insecure hosts crash with an `IllegalArgumentException` on Android.


## Version 4.7.0

_2020-05-17_

      allocationLimit = settings.getMaxConcurrentStreams()

      if (allocationLimit < oldLimit) {
        // We might need new connections to keep policies satisfied
        connectionPool.scheduleOpener(route.address)
      } else if (allocationLimit > oldLimit) {
        // We might no longer need some connections
        connectionPool.scheduleCloser()
      }
    }
  }

    return exchange?.hasFailure == true &&
      exchangeFinder!!.routePlanner.hasNext(exchange?.connection)
  }

  /**
   * Returns a string that describes this call. Doesn't include a full URL as that might contain
   * sensitive information.
   */
  private fun toLoggableString(): String {
    return (
      (if (isCanceled()) "canceled " else "") +
        (if (forWebSocket) "web socket" else "call") +

2500..2595    ; valid                  ;      ; NV8    # 1.1  BOX DRAWINGS LIGHT HORIZONTAL..RIGHT ONE EIGHTH BLOCK
2596..259F    ; valid                  ;      ; NV8    # 3.2  QUADRANT LOWER LEFT..QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT
25A0..25EF    ; valid                  ;      ; NV8    # 1.1  BLACK SQUARE..LARGE CIRCLE

        -> {
          // These codes can be cached unless headers forbid it.
        }

        HTTP_MOVED_TEMP,
        HTTP_TEMP_REDIRECT,
        -> {
          // These codes can only be cached with the right response headers.
          // http://tools.ietf.org/html/rfc7234#section-3
          // s-maxage is not checked because OkHttp is a private cache that should ignore s-maxage.
          if (response.header("Expires") == null &&

              UnknownHostException(e.message).apply {
                initCause(e)
              },
            )
          }
        },
      )
    } catch (e: Exception) {
      // Handle any errors that might leak out
      // https://issuetracker.google.com/issues/319957694
      callback.onFailure(
        hostname,
        UnknownHostException(e.message).apply {
          initCause(e)
        },
      )
    }
  }

            }
          }
        }
      }

      // Update the connection flow control, as this is a shared resource.
      // Even if our stream doesn't need more data, others might.
      // But delay updating the stream flow control until that stream has been
      // consumed
      updateConnectionFlowControl(byteCount)

      // Notify that buffer size changed

        .build(),
    )

    // At least three request/response pairs are required because after the first request is cached
    // a different execution path might be taken. Thus modifications to the cache applied during
    // the second request might not be visible until another request is performed.
    assertThat(get(server.url("/")).body.string()).isEqualTo("ABCABCABC")

      "FINE: Q10000 scheduled after 200 µs: task two",
    )
  }

  /**
   * We don't track the active task in scheduled tasks. This behavior might be a mistake, but it's
   * cumbersome to implement properly because the active task might be a cancel.
   */
  @Test fun scheduledTasksDoesNotIncludeRunningTask() {
    val task =
      object : Task("task one") {
        val schedules = mutableListOf(200.µs)

          canUseHeaderValue = false
        } else {
          headerValue = value
        }
      }
      name.equals("Pragma", ignoreCase = true) -> {
        // Might specify additional cache-control params. We invalidate just in case.
        canUseHeaderValue = false
      }
      else -> {
        continue@loop
      }
    }

    var pos = 0