mac := hmac.New(sha256.New, extKey)
		mac.Write(sealedKey.IV[:])
		mac.Write([]byte(domain))
		mac.Write([]byte(SealAlgorithm))
		mac.Write([]byte(path.Join(bucket, object))) // use path.Join for canonical 'bucket/object'
		unsealConfig = sio.Config{MinVersion: sio.Version20, Key: mac.Sum(nil), CipherSuites: fips.DARECiphers()}
	case InsecureSealAlgorithm:
		sha := sha256.New()
		sha.Write(extKey)
		sha.Write(sealedKey.IV[:])

    return byteSink.wasStreamClosed();
  }

  @Override
  public Writer openStream() throws IOException {
    // using TestByteSink's output stream to get option behavior, so flush to it on every write
    return new FilterWriter(new OutputStreamWriter(byteSink.openStream(), UTF_8)) {
      @Override
      public void write(int c) throws IOException {
        super.write(c);
        flush();
      }

      @Override

    def "stores binary data"() {
        def store = new DefaultBinaryStore(temp.file("foo.bin"))

        when:
        store.write({ it.writeInt(10) } as BinaryStore.WriteAction)
        store.write({ it.writeString("x") } as BinaryStore.WriteAction)
        def data1 = store.done()
        store.write({ it.writeString("y") } as BinaryStore.WriteAction)
        def data2 = store.done()

        then:

	h := hash.New()
	h.WriteString(t.clusterName)
	h.Write(Separator)
	h.WriteString(t.proxyVersion)
	h.Write(Separator)
	h.WriteString(util.LocalityToString(t.locality))
	h.Write(Separator)
	h.WriteString(t.proxyClusterID)
	h.Write(Separator)
	h.WriteString(strconv.FormatBool(t.proxySidecar))
	h.Write(Separator)
	h.WriteString(strconv.FormatBool(t.http2))
	h.Write(Separator)
	h.WriteString(strconv.FormatBool(t.downstreamAuto))

        testFile("settings.gradle").write("   \n  ");
        testFile("build.gradle").write("   ");
        inTestDirectory().withTasks("help").run();
    }

    @Test
    public void canDetermineRootProjectAndDefaultProjectBasedOnCurrentDirectory() {
        File rootDir = getTestDirectory();
        File childDir = new File(rootDir, "child");

        testFile("settings.gradle").write("include('child')");

        given:
        def streamBuf = new StreamByteBuffer(32000)
        def output = streamBuf.getOutputStream()

        when:
        output.write(1)
        output.write(2)
        output.write(3)
        output.write(255)
        output.close()

        then:
        def input = streamBuf.getInputStream()
        input.read() == 1
        input.read() == 2
        input.read() == 3

func (i *instance) Write(p []byte) (n int) {
	n, _ = i.hash.Write(p)
	return
}

// Write wraps the Hash.Write function call
// Hash.Write error always return nil, this func simplify caller handle error
func (i *instance) WriteString(s string) (n int) {
	n, _ = i.hash.WriteString(s)
	return
}

func (i *instance) Sum64() uint64 {
	return i.hash.Sum64()
}

func (i *instance) Sum() string {
	sum := i.hash.Sum(nil)

        expect:
        write([:]) == ""
    }

    def "empty properties with comment are written properly"() {
        expect:
        write([:], "Line comment") == normalize("""
            #Line comment
            """)
    }

    def "simple properties are written sorted alphabetically"() {
        expect:
        write([one: "1", two: "2", three: "three"], "Line comment") == normalize("""

	fw := Wrap(w)
	for i := 0; i < 10; i++ {
		_, err := fw.Write([]byte("Test write"))
		if err != nil {
			t.Errorf("Unexpected error while writing with flush writer: %v", err)
		}
	}
	if w.flushCount != 10 {
		t.Errorf("Flush not called the expected number of times. Actual: %d", w.flushCount)
	}
	if w.writeCount != 10 {
		t.Errorf("Write not called the expected number of times. Actual: %d", w.writeCount)
	}
}

        firstBuildCacheKey != null
        originBuildInvocationId(":write") == null

        when:
        succeeds "write"

        then:
        executed ":write"
        def secondBuildId = buildInvocationId
        firstBuildId != secondBuildId
        with(origin(":write")) {
            buildInvocationId == firstBuildId
            buildCacheKey == firstBuildCacheKey
        }

        when: