* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.connection

/**
 * Used when we were unsuccessful in the planning phase of a connection:
 *
 *  * A DNS lookup failed
 *  * The configuration is incapable of carrying the request, such as when the client is configured

    }
  }

  // TODO GET preferred order - with tests to confirm this
  // 1. successful fresh cached GET response
  // 2. unsuccessful (404, 500) fresh cached GET response
  // 3. successful network response
  // 4. successful stale cached GET response
  // 5. unsuccessful response
  @Test
  fun usesCache() {
    val cache = Cache(cacheFs, "cache".toPath(), (100 * 1024).toLong())

    serverIpv4.shutdown()
    serverIpv6.shutdown()

    val call = client.newCall(Request(url))
    assertFailsWith<IOException> {
      call.execute()
    }

    // In the process we made two unsuccessful connection attempts.
    assertThat(listener.recordedEventTypes().filter { it == "ConnectStart" }).hasSize(2)
    assertThat(listener.recordedEventTypes().filter { it == "ConnectFailed" }).hasSize(2)
  }

	}

	// check not at EOF
	b.WriteString("abcdefghijklmnopqrstuvwxyz")

	// after unsuccessful read
	if n, err := b.Read(nil); n != 0 || err != nil {
		t.Fatalf("Read(nil) = %d,%v; want 0,nil", n, err)
	}
	if err := b.UnreadByte(); err == nil {
		t.Fatal("UnreadByte after Read(nil): got no error")
	}

	// after successful read
	if _, err := b.ReadBytes('m'); err != nil {
		t.Fatalf("ReadBytes: %v", err)
	}

</p>

<p class="rule">
A successful call to <code>l.TryLock</code> (or <code>l.TryRLock</code>)
is equivalent to a call to <code>l.Lock</code> (or <code>l.RLock</code>).
An unsuccessful call has no synchronizing effect at all.
As far as the memory model is concerned,
<code>l.TryLock</code> (or <code>l.TryRLock</code>)

 *  Fix: Correctly canonicalize IPv6 addresses in `HttpUrl`. This prevented OkHttp from trusting
    HTTPS certificates issued to certain IPv6 addresses.
 *  Fix: Don't reuse connections after an unsuccessful `Expect: 100-continue`.
 *  Fix: Handle either `TLS_` or `SSL_` prefixes for cipher suite names. This is necessary for
    IBM JVMs that use the `SSL_` prefix exclusively.

		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrAdminConfigNotificationTargetsFailed: {
		Code:           "XMinioAdminNotificationTargetsTestFailed",
		Description:    "Configuration update failed due an unsuccessful attempt to connect to one or more notification servers",
		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrAdminProfilerNotEnabled: {
		Code:           "XMinioAdminProfilerNotEnabled",

          <type>String</type>
        </field>
        <field>
          <name>notifiers</name>
          <version>4.0.0+</version>
          <description>Configuration for notifying developers/users when a build is unsuccessful,
            including user information and notification mode.</description>
          <association>
            <multiplicity>*</multiplicity>
            <type>Notifier</type>
          </association>

            """
            include(":failed-test-with-leftover")
            include(":successful-test-with-leftover")
            include(":failed-report-with-leftover")
            include(":flaky-test-with-leftover")
            include(":flaky-test-without-leftover")
            include(":successful-report")
            """.trimIndent()
        )

        fun File.writeFlakyTest(fail: Boolean) {

                    "summary": "Read Dict",
                    "operationId": "read_dict_dict_get",
                    "responses": {
                        "200": {
                            "description": "Successful Response",
                            "content": {
                                "application/json": {
                                    "schema": {"$ref": "#/components/schemas/Model"}