}

    /**
     * Serialize the inbound Model instance to a StringWriter, perform the regex replacement to resolve
     * POM expressions, then re-parse into the resolved Model instance.
     * <p>
     * <b>NOTE:</b> This will result in a different instance of Model being returned!!!
     *
     * @param model The inbound Model instance, to serialize and reference for expression resolution

        "windowSizeIncrement == 0 || windowSizeIncrement > 0x7fffffffL: $windowSizeIncrement"
      }
      if (logger.isLoggable(FINE)) {
        logger.fine(
          frameLogWindowUpdate(
            inbound = false,
            streamId = streamId,
            length = 4,
            windowSizeIncrement = windowSizeIncrement,
          ),
        )
      }
      frameHeader(
        streamId = streamId,

      logger.fine(frameLog(true, streamId, length, TYPE_WINDOW_UPDATE, flags))
      throw e
    }
    if (logger.isLoggable(FINE)) {
      logger.fine(
        frameLogWindowUpdate(
          inbound = true,
          streamId = streamId,
          length = length,
          windowSizeIncrement = increment,
        ),
      )
    }
    handler.windowUpdate(streamId, increment)
  }

     *
     * For tests this must be big enough to realize real compression on test messages like
     * 'aaaaaaaaaa...'. Our tests check if compression was applied just by looking at the size if
     * the inbound buffer.
     */
    const val DEFAULT_MINIMUM_DEFLATE_SIZE = 1024L
  }

  }

  /**
   * OkHttp currently doesn't implement failing the request body stream independently of failing the
   * corresponding response body stream. This is necessary if we want servers to be able to stop
   * inbound data and send an early 400 before the request body completes.
   *
   * This test sends a slow request that is canceled by the server. It expects the response to still
   * be readable after the request stream is canceled.

	case debugShutdown:
		c.updateState(StateShutdown)
	case debugKillInbound:
		c.connMu.Lock()
		defer c.connMu.Unlock()
		if c.debugInConn != nil {
			if debugPrint {
				fmt.Println("debug: closing inbound connection")
			}
			c.debugInConn.Close()
		}
	case debugKillOutbound:
		c.connMu.Lock()
		defer c.connMu.Unlock()
		if c.debugInConn != nil {
			if debugPrint {

    T lbound = uncheckedCastNullableTToT(getLowerEndpoint());
    int cmp = comparator.compare(t, lbound);
    return cmp < 0 | (cmp == 0 & getLowerBoundType() == OPEN);
  }

  boolean tooHigh(@ParametricNullness T t) {
    if (!hasUpperBound()) {
      return false;
    }
    // The cast is safe because of the hasUpperBound() check.
    T ubound = uncheckedCastNullableTToT(getUpperEndpoint());

    T lbound = uncheckedCastNullableTToT(getLowerEndpoint());
    int cmp = comparator.compare(t, lbound);
    return cmp < 0 | (cmp == 0 & getLowerBoundType() == OPEN);
  }

  boolean tooHigh(@ParametricNullness T t) {
    if (!hasUpperBound()) {
      return false;
    }
    // The cast is safe because of the hasUpperBound() check.
    T ubound = uncheckedCastNullableTToT(getUpperEndpoint());

      derivedSuites.add(createSubMultisetSuite(parentBuilder, Bound.NO_BOUND, Bound.EXCLUSIVE));
      derivedSuites.add(createSubMultisetSuite(parentBuilder, Bound.NO_BOUND, Bound.INCLUSIVE));
      derivedSuites.add(createSubMultisetSuite(parentBuilder, Bound.EXCLUSIVE, Bound.NO_BOUND));
      derivedSuites.add(createSubMultisetSuite(parentBuilder, Bound.EXCLUSIVE, Bound.EXCLUSIVE));

    TypeVariable<?> noBound = withBounds(noBoundJvmType);
    TypeVariable<?> objectBound = withBounds(objectBoundJvmType, Object.class);
    TypeVariable<?> upperBound = withBounds(upperBoundJvmType, Number.class, CharSequence.class);

    assertEqualTypeVariable(noBoundJvmType, noBound);
    assertEqualTypeVariable(noBoundJvmType, withBounds(noBoundJvmType, Object.class));