byte[] dst = new byte[16];

        // Test with zero time
        SMBUtil.writeTime(0L, dst, 0);
        long writtenValue = SMBUtil.readInt8(dst, 0);
        assertEquals(0L, writtenValue);

        // Test with non-zero time
        long testTime = 1500000000000L; // Unix timestamp in milliseconds
        SMBUtil.writeTime(testTime, dst, 8);
        long writtenTime = SMBUtil.readInt8(dst, 8);

    }

    @Override
    int writeDataWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        writeTime(createTime, dst, dstIndex);
        dstIndex += 8;
        writeInt8(0L, dst, dstIndex);
        dstIndex += 8;
        writeTime(lastWriteTime, dst, dstIndex);
        dstIndex += 8;
        writeInt8(0L, dst, dstIndex);
        dstIndex += 8;
        /* Samba 2.2.7 needs ATTR_NORMAL

        if (LogStream.level >= 4) {
            SmbFile.log.println("write: fid=" + file.fid + ",off=" + off + ",len=" + len);
        }

        int w;
        do {
            w = len > writeSize ? writeSize : len;
            if (useNTSmbs) {
                reqx.setParam(file.fid, fp, len - w, b, off, w);
                if ((flags & 1) != 0) {
                    reqx.setParam(file.fid, fp, len, b, off, w);

	// write "end"
	err = en.Append(0x8d, 0xa3, 0x65, 0x6e, 0x64)
	if err != nil {
		return
	}
	err = en.WriteTime(z.ended)
	if err != nil {
		err = msgp.WrapError(err, "ended")
		return
	}
	// write "st"
	err = en.Append(0xa2, 0x73, 0x74)
	if err != nil {
		return
	}
	err = en.WriteTime(z.started)
	if err != nil {
		err = msgp.WrapError(err, "started")
		return
	}
	// write "lh"

   */
  @Override
  public void writeFloat(float v) throws IOException {
    writeInt(Float.floatToIntBits(v));
  }

  /**
   * Writes an {@code int} as specified by {@link DataOutputStream#writeInt(int)}, except using
   * little-endian byte order.
   *
   * @throws IOException if an I/O error occurs
   */
  @Override
  public void writeInt(int v) throws IOException {
    out.write(0xFF & v);

    writeFile(getCleanFile("g2", 0), "C")
    writeFile(getCleanFile("g2", 1), "D")
    writeFile(getCleanFile("g2", 1), "D")
    writeFile(cacheDir / "otherFile0", "E")
    writeFile(dir2 / "otherFile1", "F")
  }

  private fun assertGarbageFilesAllDeleted() {
    assertThat(filesystem.exists(getCleanFile("g1", 0))).isFalse()
    assertThat(filesystem.exists(getCleanFile("g1", 1))).isFalse()

		/dev/2 /path/to/1/2 type2 flags,1,2=3 2 2
                /dev/3 /path/to/1.1 type3 flags,1,2=3 3 3
		`
	var err error
	dir := t.TempDir()
	mountsPath := filepath.Join(dir, "mounts")
	if err = os.WriteFile(mountsPath, []byte(successCase), 0o666); err != nil {
		t.Fatal(err)
	}
	// Failure case where we detected successfully cross device mounts.
	{
		absPaths := []string{"/path/to/1"}

  @Throws(InterruptedException::class)
  fun writePingAndAwaitPong() {
    writePing()
    awaitPong()
  }

  /** For testing: sends a ping to be awaited with [awaitPong]. */
  @Throws(InterruptedException::class)
  fun writePing() {
    withLock {
      awaitPingsSent++
    }

    // 0x4f 0x4b 0x6f 0x6b is "OKok".
    writePing(false, AWAIT_PING, 0x4f4b6f6b)
  }

  /** For testing: awaits a pong. */

            const newOperationId = operationId.substring(toRemove.length)
            operation.operationId = newOperationId
          }
        }
      }
    }

    await fs.promises.writeFile(
      filePath,
      JSON.stringify(openapiContent, null, 2),
    )
    console.log('File successfully modified')
  } catch (err) {
    console.error('Error:', err)
  }
}

	}

	entitlementsPath := filepath.Join(tmpdir, "Entitlements.plist")
	if err := os.WriteFile(entitlementsPath, []byte(entitlementsPlist()), 0744); err != nil {
		return err
	}
	if err := os.WriteFile(filepath.Join(appdir, "Info.plist"), []byte(infoPlist(pkgpath)), 0744); err != nil {
		return err
	}
	if err := os.WriteFile(filepath.Join(appdir, "ResourceRules.plist"), []byte(resourceRules), 0744); err != nil {
		return err