labels.errorName=Error Name
labels.expiredTime=Expired Time
labels.expires=Expires
labels.failureCountThreshold=Failure Count
labels.fileConfigName=File Crawl Config Name
labels.fileName=File Name
labels.handlerName=Handler Name
labels.handlerParameter=Parameter
labels.handlerScript=Script
labels.popularWord=Popular Word
labels.ignoreFailureType=Ignored Failure Type
labels.lastAccessTime=Last Access Time
labels.notificationTo=Notification To
labels.num=Num

        ChannelInfo channel = new ChannelInfo("failover-test", mockTransport, nic, nic);
        channel.setState(ChannelState.ESTABLISHED);

        // Simulate failure
        IOException failure = new IOException("Connection lost");
        failover.handleFailure(channel, failure);

        // Verify channel state changed
        assertFalse(channel.isHealthy());
        assertEquals(ChannelState.FAILED, channel.getState());
    }

    public String appendQueryParameter;

    /** The login required setting. */
    public String loginRequired;

    /** The ignore failure type setting. */
    public String ignoreFailureType;

    /** The failure count threshold setting. */
    public String failureCountThreshold;

    /** The popular word setting. */
    public String popularWord;

    return super.getName() + '[' + suiteName + ']';
  }

  /**
   * Asserts that the given object is non-null, with a better failure message than {@link
   * TestCase#assertNull(String, Object)}.
   *
   * <p>The {@link TestCase} version (which is from JUnit 3) produces a failure message that does
   * not include the value of the object.
   *
   * @since 33.4.0
   */

          hasBody -> requestBody.buffer.readByteString()
          else -> null
        },
      connectionIndex = connectionIndex,
      exchangeIndex = exchangeIndex,
      socket = socket,
      failure = failure,
    )
  }

  @Throws(IOException::class)
  private fun handleWebSocketUpgrade(
    socket: MockWebServerSocket,
    request: RecordedRequest,
    response: MockResponse,
  ) {

     * <p>If the combiningCallable throws an {@code ExecutionException}, the cause of the thrown
     * {@code ExecutionException} will be extracted and used as the failure of the derived step.
     *
     * <p>If the combiningCallable throws any other exception, it will be used as the failure of the
     * derived step.
     *
     * <p>If an exception is thrown after the combiningCallable creates a {@code ClosingFuture},

    headers = headers,
    chunkSizes = chunkSizes ?: listOf(),
    bodySize = bodySize,
    body = Buffer().write(body ?: ByteString.EMPTY),
    sequenceNumber = exchangeIndex,
    failure = failure,
    method = method,
    path = target,
    handshake = handshake,
    requestUrl = url,

    }

    /**
     * Updates the heartbeat timestamp to current time and resets failure count.
     */
    public void updateHeartbeat() {
        this.lastHeartbeat = System.currentTimeMillis();
        this.heartbeatFailures = 0;
    }

    /**
     * Increments the heartbeat failure count.
     */
    public void incrementHeartbeatFailures() {
        this.heartbeatFailures++;
    }

   * with chunked encoding.
   */
  public val chunkSizes: List<Int>?,
  /**
   * The failure MockWebServer recorded when attempting to decode this request. If, for example,
   * the inbound request was truncated, this exception will be non-null.
   */
  public val failure: IOException? = null,
) {
  public val requestLine: String
    get() = "$method $target $version"

@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
/**
 * Annotation marking a test as flaky, and requires extra logging and linking against
 * a known github issue.  This does not ignore the failure.
 */