}

  companion object {
    fun uppercase(original: ResponseBody): ResponseBody =
      object : ResponseBody() {
        override fun contentType() = original.contentType()

        override fun contentLength() = original.contentLength()

        override fun source() = uppercase(original.source()).buffer()
      }

    private fun uppercase(original: Source): Source {

            }
        }

        return to;
    }

    private static <T> List<T> copyList(List<T> original) {
        List<T> copy = null;

        if (original != null) {
            copy = new ArrayList<>();

            if (!original.isEmpty()) {
                copy.addAll(original);
            }
        }

        return copy;
    }

        assertEquals(36, decodedBytes); // decode reads 36 bytes (no padding)
        assertEquals(original.getCreateTime(), decoded.getCreateTime());
        assertEquals(original.getLastAccessTime(), decoded.getLastAccessTime());
        assertEquals(original.getLastWriteTime(), decoded.getLastWriteTime());
        assertEquals(original.getAttributes(), decoded.getAttributes());
    }

    @Test
    @DisplayName("Test toString method")

Mas se você tiver cabeçalhos personalizados desejando que um cliente em um navegador esteja apto a ver, você precisa adicioná-los às suas configurações CORS ([CORS (Cross-Origin Resource Sharing)](cors.md){.internal-link target=_blank}) usando o parâmetro `expose_headers` documentado em <a href="https://www.starlette.io/middleware/#corsmiddleware" class="external-link" target="_blank">Documentos CORS da Starlette</a>.

    }

    @Test
    public void testHandleGuidRoundTrip() {
        HandleGuid original = new HandleGuid();
        byte[] bytes = original.toBytes();
        HandleGuid reconstructed = new HandleGuid(bytes);

        assertEquals(original, reconstructed);
        assertEquals(original.toString(), reconstructed.toString());
        assertEquals(original.hashCode(), reconstructed.hashCode());
    }

    @Test

        newOutput = newOutputs;
    }

    /**
     * Gets the original input word.
     *
     * @return The original input word.
     */
    public String getInput() {
        return input;
    }

    /**
     * Gets the original output stem.
     *
     * @return The original output stem.
     */
    public String getOutput() {
        return output;
    }

   * returns an arbitrary (but consistent) endpoint of the origin edge.
   */
  public final N nodeU() {
    return nodeU;
  }

  /**
   * Returns the node {@link #adjacentNode(Object) adjacent} to {@link #nodeU()} along the origin
   * edge. If this {@link EndpointPair} {@link #isOrdered()}, this is equal to {@link #target()}.
   */
  public final N nodeV() {

/**
 * The concrete route used by a connection to reach an abstract origin server. When creating a
 * connection the client has many options:
 *
 *  * **HTTP proxy:** a proxy server may be explicitly configured for the client. Otherwise, the
 *    [proxy selector][java.net.ProxySelector] is used. It may return multiple proxies to attempt.
 *  * **IP address:** whether connecting directly to an origin server or a proxy, opening a socket

 * @param <E> Edge parameter type
 */
abstract class AbstractDirectedNetworkConnections<N, E> implements NetworkConnections<N, E> {
  /** Keys are edges incoming to the origin node, values are the source node. */
  final Map<E, N> inEdgeMap;

  /** Keys are edges outgoing from the origin node, values are the target node. */
  final Map<E, N> outEdgeMap;

  private int selfLoopCount;

    }

    /**
     * Gets the size of the original unencrypted message
     *
     * @return the original message size
     */
    public int getOriginalMessageSize() {
        return this.originalMessageSize;
    }

    /**
     * Sets the size of the original unencrypted message
     *
     * @param originalMessageSize
     *            the original message size to set
     */