for (i in 0..9) {
                  sink.writeByte(0)
                  sink.flush()
                  sleep(100)
                }
                fail("Expected connection to be closed")
              }
            },
          ).build(),
      )
    interruptLater(500)
    assertFailsWith<IOException> {
      call.execute()
    }
  }

  @Test

            this.recordedReadTimeout = timeout;
            super.setReadTimeout(timeout);
        }
    }

    /**
     * CurlRequest subclass that overrides only open(URL) to inject a mock connection.
     * This ensures the real connect() code path is exercised (timeout, headers, onConnect, etc.).
     */
    class OpenOverrideCurlRequest extends CurlRequest {

    /** Error code for invalid response from the LLM provider. */
    public static final String ERROR_INVALID_RESPONSE = "invalid_response";

    /** Error code for connection errors. */
    public static final String ERROR_CONNECTION = "connection_error";

    /** Error code for unknown errors. */
    public static final String ERROR_UNKNOWN = "unknown";

        // Verify backward compatibility with Exception parameter
        String message = "SSO login failed";

        // Test with various Exception types
        IOException ioException = new IOException("Connection failed");
        SsoLoginException exception1 = new SsoLoginException(message, ioException);
        assertTrue(exception1.getCause() instanceof IOException);

 * HTTP/2 support allows all requests to the same host to share a socket.
 * Connection pooling reduces request latency (if HTTP/2 isn’t available).
 * Transparent GZIP shrinks download sizes.
 * Response caching avoids the network completely for repeat requests.

OkHttp perseveres when the network is troublesome: it will silently recover from common connection

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.connection

import assertk.assertThat
import assertk.assertions.containsExactlyInAnyOrder
import assertk.assertions.isFalse
import assertk.assertions.isNotNull
import assertk.assertions.isNull
import assertk.assertions.isTrue

        Property<String> defaultDokkaVersion = getDokkaExtension(project).getDokkaEngineVersion();
        defaultDokkaVersion.set(dokkaVersionOverride.convention(defaultDokkaVersion.get()));
    }

    /**
     * The name of the module is part of the URI for deep links, changing it will break existing links.

        SearchEngineClient searchEngineClient = new SearchEngineClient() {
            @Override
            public PingResponse ping() {
                throw new RuntimeException("Connection failed");
            }
        };

        SystemHelper systemHelper = new SystemHelper() {
            @Override
            public String getHostname() {
                return "test-hostname";

                invalid_response: 'Received an invalid response from the AI service. Please try again.',
                connection_error: 'Unable to connect to the AI service. Please check the network connection.',
                unknown: 'An error occurred. Please try again.'
            }
        }
    };

    var state = {
        sessionId: null,
        isProcessing: false,
        eventSource: null,

    private int currentPageNumber;

    /** The unique identifier for the file authentication entry. */
    public String id;

    /** The port number for the file authentication connection. */
    public String port;

    /** The username for file authentication. */
    public String username;

    /** The file configuration ID associated with this authentication. */
    public String fileConfigId;