* even to an intermediate buffer) should be considerably more efficient than potentially
   * copying the CharSequence to a String and then calling getBytes(Charset) on that String, in
   * reality there are optimizations that make the getBytes(Charset) approach considerably faster,
   * at least for commonly used charsets like UTF-8.
   */

  @Override
  @CanIgnoreReturnValue

            return JdkDownloadPluginFuncTest.class.getResourceAsStream("fake_adoptium_" + effectivePlatform + "." + extension(platform)).getBytes()
        } else if (vendor.equals(VENDOR_OPENJDK)) {
            JdkDownloadPluginFuncTest.class.getResourceAsStream("fake_openjdk_" + effectivePlatform + "." + extension(platform)).getBytes()
        }
    }

    private static boolean isMac(String platform) {

                    parseTokenPage(tokenPattern, responseParams, entity);
                } else {
                    String content;
                    try {
                        content = new String(InputStreamUtil.getBytes(entity.getContent()), Constants.UTF_8_CHARSET);
                    } catch (final IOException e) {
                        content = e.getMessage();
                    }

        // flags (2 bytes, LE) -> 0x0000
        assertEquals((byte) 0x00, dst[10]);
        assertEquals((byte) 0x00, dst[11]);

        // filename bytes, then null terminator
        byte[] nameBytes = name.getBytes();
        for (int i = 0; i < nameBytes.length; i++) {
            assertEquals(nameBytes[i], dst[12 + i], "Filename byte mismatch at index " + i);
        }

    }
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putString(CharSequence charSequence, Charset charset) {
    return putBytes(charSequence.toString().getBytes(charset));
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putBytes(byte[] bytes) {
    return putBytes(bytes, 0, bytes.length);
  }

  @Override
  @CanIgnoreReturnValue

        // Expected format: buffer format (0x04) + path string (null terminated)
        byte[] expected = new byte[directoryName.length() + 2];
        expected[0] = 0x04; // Buffer format
        System.arraycopy(directoryName.getBytes(StandardCharsets.UTF_8), 0, expected, 1, directoryName.length());
        expected[directoryName.length() + 1] = 0x00; // Null terminator

        byte[] dst = new byte[100];

  private final TestByteSource byteSource;

  public TestCharSource(String content, TestOption... options) {
    this.byteSource = new TestByteSource(content.getBytes(UTF_8), options);
  }

  @Override
  public boolean wasStreamOpened() {
    return byteSource.wasStreamOpened();
  }

  @Override
  public boolean wasStreamClosed() {

    /**
     * Context name for durable handle request
     */
    public static final String CONTEXT_NAME = "DHnQ";

    private static final byte[] CONTEXT_NAME_BYTES = CONTEXT_NAME.getBytes();
    private static final int STRUCTURE_SIZE = 16;

    private long reserved; // Must be zero

    /**
     * Create a new durable handle request
     */
    public DurableHandleRequest() {

        file1 = File.createTempFile("synonym", ".txt");
        FileUtil.writeBytes(file1.getAbsolutePath(),
                "a1=>A1\nb1,b2 => B1\nc1 => C1, C2\nx1,X1\ny1, Y1, y2"
                        .getBytes(Constants.UTF_8));
        // TODO set up opensearch and dictionaryManager
        synonymFile = new SynonymFile("1", file1.getAbsolutePath(), new Date());
    }

    @Override

     * @param text
     *            the text to encrypt
     * @return the encrypted text
     */
    public String encryptText(final String text) {
        try {
            return Base64Util.encode(encrypt(text.getBytes(charsetName)));
        } catch (final UnsupportedEncodingException e) {
            throw new UnsupportedEncodingRuntimeException(e);
        }
    }

    /**
     * Encrypts the given text.
     *