assertTrue(result.contains("Session Id: " + thumbnailJob.sessionId));
    }

    // Test execute with timeout
    public void test_execute_withTimeout() {
        thumbnailJob.numOfThreads(2);
        thumbnailJob.timeout = 120; // Set timeout
        thumbnailJob.processTimeout = true;

        testProcessHelper.exitValue = -1;
        testProcessHelper.processOutput = "Process terminated";

        // Result should contain session ID info
        assertTrue(result.contains("Python Process terminated."));
    }

    // Test execute with timeout
    public void test_execute_withTimeout() {
        pythonJob.filename("timeout.py");
        pythonJob.timeout = 60; // Set timeout
        pythonJob.processTimeout = true;

        testProcessHelper.exitValue = -1;
        testProcessHelper.processOutput = "Process terminated";

   * value. Otherwise, a call that passes one {@code loader} may return the result of another call
   * with a differently behaving {@code loader}. For example, a call that requests a short timeout
   * for an RPC may wait for a similar call that requests a long timeout, or a call by an
   * unprivileged user may return a resource accessible only to a privileged user making a similar

      call: RealCall,
      e: IOException?,
    )

    fun noNewExchanges()

    fun cancel()
  }

  companion object {
    /**
     * The timeout to use while discarding a stream of input data. Since this is used for connection
     * reuse, this timeout should be significantly less than the time it takes to establish a new
     * connection.
     */
    const val DISCARD_STREAM_TIMEOUT_MILLIS = 100
  }

        assertNull(exception.getCause());
    }

    public void test_exceptionChaining() {
        // Test exception chaining with multiple levels
        Exception rootCause = new Exception("Network timeout");
        Exception middleCause = new Exception("SSO provider unreachable", rootCause);
        SsoProcessException topException = new SsoProcessException("SSO authentication failed", middleCause);

    if (canceled) {
      stream!!.closeLater(ErrorCode.CANCEL)
      throw IOException("Canceled")
    }
    stream!!.readTimeout().timeout(chain.readTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
    stream!!.writeTimeout().timeout(chain.writeTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
  }

  override fun flushRequest() {
    http2Connection.flush()
  }

  override fun finishRequest() {

	return=$?
	if [ $return -eq 0 ]; then
		i=0
		timeout=10
		# Wait for the process to be properly started before exiting
		until { kill -0 `cat "$PID_FILE"`; } >/dev/null 2>&1
		do
			sleep 1
			i=$(($i + 1))
			if [ $i -gt $timeout ]; then
				log_end_msg 1
				exit 1
			fi
		done
	fi
	log_end_msg $return
	exit $return
	;;		

import okio.buffer
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Assertions.assertArrayEquals
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Timeout

@Timeout(5)
@Tag("Slow")
class Http2ConnectionTest {
  private val peer = MockHttp2Peer()
  private val taskFaker = TaskFaker()

  @AfterEach fun tearDown() {
    peer.close()
    taskFaker.close()
  }

      }

      val read = source.read(sink, minOf(byteCount, left.toLong()))
      if (read == -1L) return -1L
      left -= read.toInt()
      return read
    }

    override fun timeout(): Timeout = source.timeout()

    @Throws(IOException::class)
    override fun close() {
    }

    @Throws(IOException::class)
    private fun readContinuationHeader() {
      val previousStreamId = streamId

import okhttp3.Headers
import okhttp3.Headers.Companion.headersOf
import okio.Buffer
import okio.ByteString
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Timeout

@Timeout(30)
class RecordedRequestTest {
  private val headers: Headers = Headers.EMPTY

  @Test fun testIPv4() {
    val socket =
      MockWebServerSocket(
        FakeSocket(