* 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

        if (content != null) {
            resource.setContentLength(content.length());
            resource.setLastModified(System.currentTimeMillis());

            inputData.setInputStream(new ByteArrayInputStream(content.getBytes(StandardCharsets.UTF_8)));
        } else {
            throw new ResourceDoesNotExistException("No content provided for " + resource.getName());
        }
    }

    @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.
     *

                }
                break;
            case 2:
                DERBitString bitString = ASN1Util.as(DERBitString.class, tagged);
                this.apOptions = bitString.getBytes()[0];
                break;
            case 3:
                ASN1TaggedObject derTicket = ASN1Util.as(ASN1TaggedObject.class, tagged);
                if (derTicket.getTagClass() != BERTags.APPLICATION) {

        // Given
        String testString = "Hello";
        byte[] buffer = new byte[testString.length()];

        // When - Manual string encoding using individual bytes
        byte[] strBytes = testString.getBytes();
        System.arraycopy(strBytes, 0, buffer, 0, strBytes.length);

        // Then
        String decoded = new String(buffer);
        assertEquals(testString, decoded);
    }

    @Test

        dst[dstIndex] = (byte) (this.replaceIfExists ? 1 : 0);
        dstIndex += 8; // 7 Reserved
        dstIndex += 8; // RootDirectory = 0

        final byte[] nameBytes = this.fileName.getBytes(StandardCharsets.UTF_16LE);

        SMBUtil.writeInt4(nameBytes.length, dst, dstIndex);
        dstIndex += 4;

        System.arraycopy(nameBytes, 0, dst, dstIndex, nameBytes.length);

    /**
     * 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() {

        }

        final StreamResponse response =
                asStream(DocumentUtil.getValue(doc, fessConfig.getIndexFieldDocId(), String.class)).contentType("text/html; charset=UTF-8")
                        .data(content.getBytes(Constants.CHARSET_UTF_8));
        response.headerContentDispositionInline(); // TODO will be fixed in lastaflute
        return response;
    }

        byte[] buffer = new byte[50];
        int used = cmd.writeBytesWireFormat(buffer, 0);
        // Calculate expected size: 1 byte for command + string bytes + 1 null terminator
        byte[] expectedString = "testfile.txt".getBytes("windows-1252");
        assertEquals(1 + expectedString.length + 1, used, "Expected exactly one command byte plus OEM string and NUL terminator");

    /**
     * Test that input stream content is not read (only validated).
     */
    public void test_getText_doesNotReadInputStream() throws Exception {
        final byte[] testData = "This data should not be read".getBytes();
        final InputStream in = new ByteArrayInputStream(testData);
        final Map<String, String> params = new HashMap<>();
        params.put(ExtractData.RESOURCE_NAME_KEY, "filename.txt");