frameHeader(
        streamId = 0,
        length = 8,
        type = TYPE_PING,
        flags = if (ack) FLAG_ACK else FLAG_NONE,
      )
      sink.writeInt(payload1)
      sink.writeInt(payload2)
      sink.flush()
    }
  }

  /**
   * Tell the peer to stop creating streams and that we last processed `lastGoodStreamId`, or zero
   * if no streams were processed.
   *

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

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

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

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

		size := utf8.EncodeRune(b[n:], r)
		nbytes, err := buf.WriteRune(r)
		if err != nil {
			t.Fatalf("WriteRune(%U) error: %s", r, err)
		}
		if nbytes != size {
			t.Fatalf("WriteRune(%U) expected %d, got %d", r, size, nbytes)
		}
		n += size
	}
	b = b[0:n]

	// Check the resulting bytes
	if !Equal(buf.Bytes(), b) {
		t.Fatalf("incorrect result from WriteRune: %q not %q", buf.Bytes(), b)
	}

    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()

							}
							err = os.WriteFile(fn+".json", []byte(filemap[file][name+".json"]), os.ModePerm)
							combineFiles[name] = append(combineFiles[name], fn)
							if err != nil {
								fmt.Println("WriteFile:", err)
							}
							err = os.WriteFile(filepath.Dir(fn)+"/filename.txt", []byte(file), os.ModePerm)
							if err != nil {
								fmt.Println("combine WriteFile:", err)
							}
						}
					}

	b, err := json.Marshal(m)
	if err != nil {
		t.Fatal(err)
	}

	if err = os.MkdirAll(pathJoin(rootPath, minioMetaBucket), os.FileMode(0o755)); err != nil {
		t.Fatal(err)
	}

	if err = os.WriteFile(pathJoin(rootPath, minioMetaBucket, formatConfigFile), b, os.FileMode(0o644)); err != nil {
		t.Fatal(err)
	}

	formatData, _, err := formatErasureMigrate(rootPath)
	if err != nil {
		t.Fatal(err)
	}

    val totalRuleBytes: Int,
    val totalExceptionRuleBytes: Int,
  ) {
    fun writeOut(sink: BufferedSink) {
      with(sink) {
        writeInt(totalRuleBytes)
        for (domain in sortedRules) {
          write(domain).writeByte(NEWLINE)
        }
        writeInt(totalExceptionRuleBytes)
        for (domain in sortedExceptionRules) {
          write(domain).writeByte(NEWLINE)
        }
      }
    }
  }

	clusterEnv := map[string]string{}
	for _, metaMap := range []map[string]string{config.ProxyMetadata, overrides} {
		for k, v := range metaMap {
			clusterEnv[k] = v
		}
	}

	return os.WriteFile(filepath.Join(dir, "cluster.env"), []byte(mapToString(clusterEnv)), filePerms)
}

// Get and store the needed certificate and token. The certificate comes from the CA root cert, and

1
201105
2

CLEAN $urlKey ${entryMetadata.length} ${entryBody.length}
"""
    fileSystem.createDirectory(cache.directoryPath)
    writeFile(cache.directoryPath, "$urlKey.0", entryMetadata)
    writeFile(cache.directoryPath, "$urlKey.1", entryBody)
    writeFile(cache.directoryPath, "journal", journalBody)
    cache = Cache(fileSystem, cache.directory.path.toPath(), Int.MAX_VALUE.toLong())
    client =

		}
	} else {
		err = en.WriteBytes(z.Data)
		if err != nil {
			err = msgp.WrapError(err, "Data")
			return
		}
	}
	err = en.WriteInt(z.NumVersions)
	if err != nil {
		err = msgp.WrapError(err, "NumVersions")
		return
	}
	err = en.WriteTime(z.SuccessorModTime)
	if err != nil {
		err = msgp.WrapError(err, "SuccessorModTime")
		return
	}
	err = en.WriteBool(z.Fresh)