int chunk2 = dataSize - chunk1;

    // Write just enough to not trip the threshold
    if (chunk1 > 0) {
      write(out, data, 0, chunk1, singleByte);
      assertTrue(ByteSource.wrap(data).slice(0, chunk1).contentEquals(source));
    }
    File file = out.getFile();
    assertThat(file).isNull();

    // Write data to go over the threshold
    if (chunk2 > 0) {
      write(out, data, chunk1, chunk2, singleByte);

from inline_snapshot import snapshot

oauth2_scheme = OAuth2AuthorizationCodeBearer(
    authorizationUrl="authorize",
    tokenUrl="token",
    auto_error=True,
    scopes={"read": "Read access", "write": "Write access"},
)


async def get_token(token: Annotated[str, Depends(oauth2_scheme)]) -> str:
    return token


app = FastAPI(dependencies=[Depends(get_token)])


@app.get("/")
async def root():

        baos.write(value & 0xFF);
        baos.write((value >> 8) & 0xFF);
        baos.write((value >> 16) & 0xFF);
        baos.write((value >> 24) & 0xFF);
    }

    private void writeLittleEndianLong(ByteArrayOutputStream baos, long value) {
        for (int i = 0; i < 8; i++) {
            baos.write((int) ((value >> (i * 8)) & 0xFF));
        }
    }

    @Test

            }
        }

        /**
         * Writes a raw line of text to the temporary file.
         *
         * @param line the line of text to write
         */
        public void write(final String line) {
            try {
                writer.write(line);
                writer.write(Constants.LINE_SEPARATOR);

            baos.write(content.length);
        } else {
            baos.write(0x82); // length of length = 2
            baos.write((content.length >> 8) & 0xFF);
            baos.write(content.length & 0xFF);
        }

        baos.write(content);
        return baos.toByteArray();
    }

        }
        return 0;
    }

    @Override
    public void write(final int b) throws SmbException {
        tmp[0] = (byte) b;
        write(tmp, 0, 1);
    }

    @Override
    public void write(final byte b[]) throws SmbException {
        write(b, 0, b.length);
    }

    @Override
    public void write(final byte b[], int off, int len) throws SmbException {
        if (len <= 0) {

        cos.write(2);
        cos.write(3);
        assertTrue(cos.isInMemory());
        cos.write(4); // Exceeds threshold
        assertFalse(cos.isInMemory());
        File file = cos.getFile();
        assertTrue(file.exists());
        cos.close();
    }

    @Test
    public void testGetDataInMemory() throws IOException {
        // getData() should return the written data when in memory

                                }
                                bw.write(mapper.writeValueAsString(dataObj));
                            } else {
                                bw.write(line);
                            }
                        } else {
                            bw.write(line);
                        }
                    }
                    bw.write("\n");
                }
                bw.flush();

     */
    public static final int SMB2_LEASE_HANDLE_CACHING = 0x02;

    /**
     * Write caching lease (W)
     */
    public static final int SMB2_LEASE_WRITE_CACHING = 0x04;

    /**
     * Read and Handle caching (RH)
     */
    public static final int SMB2_LEASE_READ_HANDLE = 0x03;

    /**
     * Read and Write caching (RW)
     */
    public static final int SMB2_LEASE_READ_WRITE = 0x05;

    /**

        File lmhostsFile = tempDir.resolve("lmhosts_empty").toFile();
        try (FileWriter writer = new FileWriter(lmhostsFile)) {
            writer.write("192.168.1.100 HOST1\n");
            writer.write("\n");
            writer.write("   \n");
            writer.write("192.168.1.101 HOST2\n");
        }

        when(mockConfig.getLmHostsFileName()).thenReturn(lmhostsFile.getAbsolutePath());