option go_package = "k8s.io/apimachinery/pkg/util/intstr";

// IntOrString is a type that can hold an int32 or a string.  When used in
// JSON or YAML marshalling and unmarshalling, it produces or consumes the
// inner type.  This allows you to have, for example, a JSON field that can
// accept a name or number.
// TODO: Rename to Int32OrString
//
// +protobuf=true
// +protobuf.options.(gogoproto.goproto_stringer)=false

  ): Sink = FaultySink(super.appendingSink(file, mustExist), file)

  override fun sink(
    file: Path,
    mustCreate: Boolean,
  ): Sink = FaultySink(super.sink(file, mustCreate), file)

  inner class FaultySink(sink: Sink, private val file: Path) : ForwardingSink(sink) {
    override fun write(
      source: Buffer,
      byteCount: Long,
    ) {
      if (writeFaults.contains(file)) {

        STATIC,

        /**
         * A scope containing both non-static and static members. A smart combined scope (as opposed to a naive combination of [KtScope]s
         * with [getCompositeScope]) avoids duplicate inner classes, as they are contained in non-static and static scopes.
         *
         * A proper combined declared member scope kind also makes it easier to cache combined scopes directly (if needed).
         */

    fun start()
  }

  private object TestThreadSerialTask : SerialTask {
    override fun start() = error("unexpected call")
  }

  inner class RunnableSerialTask(
    private val runnable: Runnable,
  ) : SerialTask {
    override fun start() {
      taskRunner.assertThreadHoldsLock()
      require(currentTask == this)
      activeThreads++

  /**
   * A source that reads the incoming data frames of a stream. Although this class uses
   * synchronization to safely receive incoming data frames, it is not intended for use by multiple
   * readers.
   */
  inner class FramingSource internal constructor(
    /** Maximum number of bytes to buffer before reporting a flow control error. */
    private val maxByteCount: Long,
    /**

  }

  override fun sameHostAndPort(url: HttpUrl): Boolean {
    return url.host == address.url.host && url.port == address.url.port
  }

  override fun close() {
    factory.close()
  }

  inner class FakePlan(
    val id: Int,
  ) : RoutePlanner.Plan {
    var planningThrowable: Throwable? = null
    var canceled = false
    var connectState = ConnectState.READY
    val connection =

        bindingContext[BindingContext.CLASS, psi]
    }

    override val isInner: Boolean
        get() = withValidityAssertion { psi.hasModifier(KtTokens.INNER_KEYWORD) }

    override val isData: Boolean
        get() = withValidityAssertion { psi.hasModifier(KtTokens.DATA_KEYWORD) }

    override val isInline: Boolean

  }

  private class Inner {
    public Inner(String s) {
      checkNotNull(s);
    }
  }

  public void testNonStaticInnerClass() {
    IllegalArgumentException expected =
        assertThrows(
            IllegalArgumentException.class,
            () -> new NullPointerTester().testAllPublicConstructors(Inner.class));

    /**
     * @return How many qualifiers needs to be dropped from [wholeType] to get [nestedType].
     *
     * Example: to get `foo.bar` from `foo.bar.Baz.Inner`, you need to drop 2 qualifiers (`Inner` and `Baz`).
     */
    private fun countQualifiersToDrop(wholeType: KtUserType, nestedType: KtUserType): Int {
        val qualifierIndex = generateSequence(wholeType) { it.qualifier }.indexOf(nestedType)

        String version = model.getVersion();
        String modVersion = replaceCiFriendlyVersion(context, version);
        builder.version(modVersion);
    }

    //
    // Infer inner reactor dependencies version
    //
    void handleReactorDependencies(ModelTransformerContext context, Model model, Path pomFile, Model.Builder builder) {
        List<Dependency> newDeps = new ArrayList<>();