*
   * <p>It is important to note that the primary purpose of the proxy object is to return control to
   * the caller when the timeout elapses; aborting the target method call is of secondary concern.
   * The particular nature and strength of the guarantees made by the proxy is
   * implementation-dependent. However, it is important that each of the methods on the target

  private val sinkBuffer: Buffer = sink.buffer
  private var writerClosed = false

  /** Lazily initialized on first use. */
  private var messageDeflater: MessageDeflater? = null

  // Masks are only a concern for client writers.
  private val maskKey: ByteArray? = if (isClient) ByteArray(4) else null
  private val maskCursor: Buffer.UnsafeCursor? = if (isClient) Buffer.UnsafeCursor() else null

          // otherwise try to presize a StringBuilder
          // it is kind of lame that we need to construct a decoder to access this value.
          // if this is a concern we could add special cases for some known charsets (like utf8)
          // or we could avoid inputstreamreader and use the decoder api directly

Vamos primeiro ver como o aplicativo da API normal se pareceria antes de adicionar o callback.

Ele terá uma *operação de rota* que receberá um corpo `Invoice`, e um parâmetro de consulta `callback_url` que conterá a URL para o callback.

Essa parte é bastante normal, a maior parte do código provavelmente já é familiar para você:

{* ../../docs_src/openapi_callbacks/tutorial001.py hl[9:13,36:53] *}

/// tip | Dica

        assertEquals(result, duplicateHostHelper.convert(url));

        url = "http://foo.com/";
        result = "http://www.foo.com/";
        assertEquals(result, duplicateHostHelper.convert(url));

        url = "http://foo.com:8080/";
        result = "http://www.foo.com:8080/";
        assertEquals(result, duplicateHostHelper.convert(url));

        url = "http://mail.bar.com/";

    Converter<String, Number> converter = Converter.<String, Number>from(forward, backward);

    assertNull(converter.convert(null));
    assertNull(converter.reverse().convert(null));

    assertEquals((Integer) 5, converter.convert("5"));
    assertEquals("5", converter.reverse().convert(5));
  }

  // Null-passthrough violates our nullness annotations, so we don't support it under J2KT.
  @J2ktIncompatible

      return Ascii.toLowerCase(word);
    }

    @Override
    String convert(CaseFormat format, String s) {
      if (format == LOWER_UNDERSCORE) {
        return s.replace('-', '_');
      }
      if (format == UPPER_UNDERSCORE) {
        return Ascii.toUpperCase(s.replace('-', '_'));
      }
      return super.convert(format, s);
    }
  },

  /** C++ variable naming convention, e.g., "lower_underscore". */

      return Ascii.toLowerCase(word);
    }

    @Override
    String convert(CaseFormat format, String s) {
      if (format == LOWER_UNDERSCORE) {
        return s.replace('-', '_');
      }
      if (format == UPPER_UNDERSCORE) {
        return Ascii.toUpperCase(s.replace('-', '_'));
      }
      return super.convert(format, s);
    }
  },

  /** C++ variable naming convention, e.g., "lower_underscore". */

     *
     * @param o
     *            the object to convert
     * @return the converted {@link Long}
     */
    public static Long toLong(final Object o) {
        return toLong(o, null);
    }

    /**
     * Converts the given object to a {@link Long}.
     *
     * @param o
     *            the object to convert
     * @param pattern
     *            the pattern string

    }

    /**
     * Converts a byte array to a hexadecimal string representation.
     *
     * @param src the source byte array to convert
     * @param srcIndex the starting index in the source array
     * @param size the number of bytes to convert from the source array
     * @return a hexadecimal string representation of the byte array
     */