try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
                PrintWriter writer = new PrintWriter(baos, false, Constants.CHARSET_UTF_8)) {
            exception.printStackTrace(writer);
            writer.flush();
            append(buf, "exception", () -> StringEscapeUtils.escapeJson(new String(baos.toByteArray(), Constants.CHARSET_UTF_8)));

import java.nio.channels.FileChannel
import okio.Buffer

/**
 * Read and write a target file. Unlike Okio's built-in `Okio.source(java.io.File file)` and `Okio.sink(java.io.File file)`
 * this class offers:
 *
 *  * **Read/write:** read and write using the same operator.
 *  * **Random access:** access any position within the file.
 *  * **Shared channels:** read and write a file channel that's shared between

        cos.write(new byte[] { 0, 1, 2, 3, 4 });
        assertFalse(cos.done);
        assertTrue(cos.isInMemory());
        cos.close();
        assertFalse(cos.done);
    }

    @Test
    public void inFile() throws IOException {
        ContentOutputStream cos = new ContentOutputStream(10, Curl.tmpDir);
        cos.write(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 });

    /**
     * Permission to write file attributes
     */
    int FILE_WRITE_ATTRIBUTES = 0x00000100; // 9
    /**
     * Standard delete permission
     */
    int DELETE = 0x00010000; // 16
    /**
     * Permission to read the security descriptor
     */
    int READ_CONTROL = 0x00020000; // 17
    /**
     * Permission to write the discretionary access control list
     */

  return BufferMockResponseBody(defensiveCopy)
}

internal class BufferMockResponseBody(
  val buffer: Buffer,
) : MockResponseBody {
  override val contentLength = buffer.size

  override fun writeTo(sink: BufferedSink) {
    buffer.copyTo(sink.buffer)
    sink.emitCompleteSegments()
  }

  analysis:
    name: Scorecard analysis
    runs-on: ubuntu-latest
    permissions:
      # Needed to upload the results to code-scanning dashboard.
      security-events: write
      # Needed to publish results and get a badge (see publish_results below).
      id-token: write
      # Uncomment the permissions below if installing in a private repository.
      # contents: read
      # actions: read

    steps:
      - name: "Checkout code"

name: Feedback

on:
  schedule:
    - cron: '0 * * * *' # every hour
  workflow_dispatch:

permissions: {}

jobs:
  feedback:
    permissions:
      issues: write
      pull-requests: write
    runs-on: ubuntu-latest
    steps:
      # Feedback loop: ask for something on PR/Issue and close if not provided or return to the queue on update.
      # https://github.com/gradle/issue-management-action/blob/main/src/feedback.ts

        setHeaderStart(response, 64);

        // Write structure header (9 bytes)
        SMBUtil.writeInt2(9, buffer, offset); // Structure size
        SMBUtil.writeInt2(80 - 64, buffer, offset + 2); // Buffer offset (relative to header)
        SMBUtil.writeInt4(50, buffer, offset + 4); // Total length of notification data

        // Write notification data at buffer offset 80
        int notifyOffset = 80;

        // Create a temporary test file
        testFile = File.createTempFile("test_stopwords", ".txt");
        testFile.deleteOnExit();

        // Write test data to file
        try (FileOutputStream fos = new FileOutputStream(testFile)) {
            fos.write(getTestContent().getBytes(StandardCharsets.UTF_8));
        }

        // Create a temporary project.properties file for SystemHelper

		if err != nil {
			t.Fatal(err)
		}
		if !ok {
			t.Fatal("did not get write lock")
		}
		rUIDs = append(rUIDs, uid)

		// RLock twice, different uid
		uid = mustGetUUID()
		arg.UID = uid
		ok, err = l.RLock(ctx, arg)
		if err != nil {
			t.Fatal(err)
		}
		if !ok {
			t.Fatal("did not get write lock")
		}
		rResources[i] = name
		rUIDs = append(rUIDs, uid)
	}