// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package typesinternal

//go:generate stringer -type=ErrorCode

type ErrorCode int

// This file defines the error codes that can be produced during type-checking.
// Collectively, these codes provide an identifier that may be used to
// implement special handling for certain types of errors.

    }
    connection.writeSynResetLater(id, errorCode)
  }

  /** Returns true if this stream was closed. */
  private fun closeInternal(
    errorCode: ErrorCode,
    errorException: IOException?,
  ): Boolean {
    lock.assertNotHeld()

    this.withLock {
      if (this.errorCode != null) {
        return false
      }
      this.errorCode = errorCode
      this.errorException = errorException

        }

        final String errorCode = UUID.randomUUID().toString();
        if (logger.isDebugEnabled()) {
            logger.debug("[{}] {}", errorCode, stacktraceString.get().replace("\n", "\\n"));
        } else {
            logger.warn("[{}] {}", errorCode, cause.getMessage());
        }
        return "error_code:" + errorCode;
    }

        System.out.println(message);
        assertContains(message, "ErrorCode=7650");
        assertContains(message, "SQLState=fooState");
        assertContains(message, "some reason");
        assertContains(message, "ErrorCode=7660");
        assertContains(message, "SQLState=barState");
        assertContains(message, "hoge reason");
        assertContains(message, "ErrorCode=7670");
        assertContains(message, "SQLState=bazState");

   * underlying input and output streams and shuts down internal task queues.
   */
  override fun close() {
    close(ErrorCode.NO_ERROR, ErrorCode.CANCEL, null)
  }

  internal fun close(
    connectionCode: ErrorCode,
    streamCode: ErrorCode,
    cause: IOException?,
  ) {
    this.assertThreadDoesntHoldLock()

    ignoreIoExceptions {
      shutdown(connectionCode)
    }

      this.data = source.readByteString(length.toLong()).toByteArray()
    }

    override fun rstStream(
      streamId: Int,
      errorCode: ErrorCode,
    ) {
      check(type == -1)
      this.type = Http2.TYPE_RST_STREAM
      this.streamId = streamId
      this.errorCode = errorCode
    }

    override fun ping(
      ack: Boolean,
      payload1: Int,
      payload2: Int,
    ) {

namespace TFL {

// Collects errors when running the pass manager.
class ErrorCollectorInstrumentation : public PassInstrumentation {
  using ConverterErrorData = tflite::metrics::ConverterErrorData;
  using ErrorCode = ConverterErrorData::ErrorCode;

 public:
  explicit ErrorCollectorInstrumentation(MLIRContext *context);

 private:
  // Instrumentation hooks. These hooks don't need to be thread-safe. The pass

    mockWebServer: MockWebServer,
  ) {
    setUp(protocol, mockWebServer)
    noRecoveryFromErrorWithRetryDisabled(ErrorCode.CANCEL)
  }

  private fun noRecoveryFromErrorWithRetryDisabled(errorCode: ErrorCode?) {
    server.enqueue(
      MockResponse(socketPolicy = ResetStreamAtStart(errorCode!!.httpCode)),
    )
    server.enqueue(MockResponse(body = "abc"))
    client =
      client.newBuilder()

  fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      require(errorCode.httpCode != -1)

      frameHeader(
        streamId = streamId,
        length = 4,
        type = TYPE_RST_STREAM,
        flags = FLAG_NONE,
      )
      sink.writeInt(errorCode.httpCode)
      sink.flush()
    }
  }

    connection.newStream(headerEntries("b", "banana"), false)

    // Verify the peer received what was expected.
    assertThat(peer.takeFrame().type).isEqualTo(Http2.TYPE_HEADERS)
    assertThat(peer.takeFrame().errorCode).isEqualTo(ErrorCode.PROTOCOL_ERROR)
  }

  @Test fun pushPromiseStreamsAutomaticallyCancel() {
    // Write the mocking script.
    peer.sendFrame().settings(Settings())
    peer.acceptFrame() // ACK