assertEquals(bytes.length, source.copyTo(sink));
    assertTrue(source.wasStreamOpened() && source.wasStreamClosed());
    assertTrue(sink.wasStreamOpened() && sink.wasStreamClosed());

    assertArrayEquals(bytes, sink.getBytes());
  }

  public void testRead_toArray() throws IOException {
    assertArrayEquals(bytes, source.read());
    assertTrue(source.wasStreamOpened() && source.wasStreamClosed());
  }

                }
                System.arraycopy( str.getBytes( UNI_ENCODING ), 0,
                                    dst, dstIndex, str.length() * 2 );
                dstIndex += str.length() * 2;
                dst[dstIndex++] = (byte)'\0';
                dst[dstIndex++] = (byte)'\0';
            } else {
                byte[] b = str.getBytes( OEM_ENCODING );

            //
            // By getting ASCII bytes (aka. strictly 1 byte per character, no variable-length magic)
            // we can safely check if the fingerprint is of the correct length.
            if (keyId.getBytes(StandardCharsets.US_ASCII).length < 40) {
                throw new InvalidGpgKeyIdsException(Collections.singletonList(keyId));
            } else {
                this.keyId = keyId.toUpperCase(Locale.ROOT);
            }

        switch (form.crudMode) {
        case CrudMode.CREATE:
            return OptionalEntity.of(new Role()).map(entity -> {
                entity.setId(Base64.getUrlEncoder().encodeToString(form.name.getBytes(Constants.CHARSET_UTF_8)));
                return entity;
            });
        case CrudMode.EDIT:
            if (form instanceof EditForm) {

    /**
     * Delimiter for entries in {@link #FILTER_SYSPROP}.
     */
    public static final String FILTER_SEPARATOR = ";";

    private static final byte[] NEWLINE = "\n".getBytes();

    private final boolean outputTree;
    private final BuildOperationListener listener;
    private final String basePath;

    private final OutputStream logOutputStream;

        }
        return new String(Base64.getUrlEncoder().encode(objectName.getBytes(Constants.UTF_8_CHARSET)), Constants.UTF_8_CHARSET);
    }

    protected static String decodeId(final String id) {
        if (id == null) {
            return StringUtil.EMPTY;
        }
        return new String(Base64.getUrlDecoder().decode(id.getBytes(Constants.UTF_8_CHARSET)), Constants.UTF_8_CHARSET);
    }

        if (outcome.method.equals("HEAD")) {
            httpExchange.sendResponseHeaders(responseCode, -1);
        } else {
            byte[] message = String.format("Failed request %s", outcome.getDisplayName()).getBytes(Charsets.UTF_8);
            httpExchange.sendResponseHeaders(responseCode, message.length);
            httpExchange.getResponseBody().write(message);
        }
    }

		return "", Entry{}, &entryNotFoundError{Err: errors.New("file incomplete")}
	}
	return file, entry, nil
}

// GetBytes looks up the action ID in the cache and returns
// the corresponding output bytes.
// GetBytes should only be used for data that can be expected to fit in memory.
func GetBytes(c Cache, id ActionID) ([]byte, Entry, error) {
	entry, err := c.Get(id)
	if err != nil {
		return nil, entry, err
	}

                    final String converted = URLEncoder.encode(target, Constants.UTF_8);
                    if (target.equals(converted)) {
                        encodedBuf.append(Base64.getUrlEncoder().encodeToString(target.getBytes(Constants.CHARSET_UTF_8)));
                    } else {
                        encodedBuf.append(converted);
                    }
                } catch (final UnsupportedEncodingException e) {

                            try (InputStream contentStream = new BufferedInputStream(new FileInputStream(file))) {
                                responseData.setResponseBody(InputStreamUtil.getBytes(contentStream));
                            } catch (final Exception e) {
                                logger.warn("I/O Exception.", e);