}
            
            def write = tasks.create("write", CustomTask)
        """

        when:
        succeeds "write"

        then:
        executedAndNotSkipped ":write"
        originBuildInvocationId(":write") == null

        when:
        buildFile << """
            write.value = "b"
        """
        succeeds("write")

        then:
        skipped(":write")

		}
	}
	h.Write(Separator)

	for _, vs := range r.DelegateVirtualServices {
		h.Write(hashToBytes(vs))
		h.Write(Separator)
	}
	h.Write(Separator)

	for _, mergedDR := range r.DestinationRules {
		for _, dr := range mergedDR.GetFrom() {
			h.WriteString(dr.Name)
			h.Write(Slash)
			h.WriteString(dr.Namespace)
			h.Write(Separator)
		}
	}
	h.Write(Separator)

        def original = snapshot("x".bytes)
        write(original)

        expect:
        original == written
    }

    def "serializes string properties"() {
        def original = string("x")
        write(original)

        expect:
        original == written
    }

    def "serializes number properties"() {
        write(value)

        expect:
        value == written

// license that can be found in the LICENSE file.

// This implements the write barrier buffer. The write barrier itself
// is gcWriteBarrier and is implemented in assembly.
//
// See mbarrier.go for algorithmic details on the write barrier. This
// file deals only with the buffer.
//
// The write barrier has a fast path and a slow path. The fast path
// simply enqueues to a per-P write barrier buffer. It's written in

            nullableFileSerializer.write(encoder, startParameter.getGradleHomeDir());
            nullableFileSerializer.write(encoder, startParameter.getProjectCacheDir());
            fileListSerializer.write(encoder, startParameter.getIncludedBuilds());

            // Other stuff
            NO_NULL_STRING_MAP_SERIALIZER.write(encoder, startParameter.getProjectProperties());

func f21a(x *int) {
	x21 = x   // ERROR "write barrier"
	y21.x = x // ERROR "write barrier"
}

func f21b(x *int) {
	x21 = &z21   // ERROR "write barrier"
	y21.x = &z21 // ERROR "write barrier"
}

func f21c(x *int) {
	y21 = struct{ x *int }{x} // ERROR "write barrier"
}

func f22(x *int) (y *int) {
	// pointer write on stack should have no write barrier.

			const b1 = 5
			const b2 = len(in) - 5
			f.Write([]byte(in[:b1]))
			f.Write([]byte(in[b1:b2]))
			f.Write([]byte(in[b2:]))
		})
	})
}

func checkJSONFilter(t *testing.T, in, want string) {
	t.Helper()
	checkJSONFilterWith(t, want, func(f *testJSONFilter) {
		f.Write([]byte(in))
	})
}

func checkJSONFilterWith(t *testing.T, want string, write func(*testJSONFilter)) {
	t.Helper()

		},
		{
			name: "Write/Splice, Reset, Write/Splice",
			run: func(sb runtime.Splice, buf *bytes.Buffer) {
				sb.Splice(testBytes0)
				buf.Write(testBytes0)

				sb.Reset()
				buf.Reset()

				sb.Splice(testBytes1)
				buf.Write(testBytes1)
			},
		},
		{
			name: "Write, Reset, Splice",
			run: func(sb runtime.Splice, buf *bytes.Buffer) {
				sb.Write(testBytes0)
				buf.Write(testBytes0)

    val bytes = binaryData(200)
    data.write("0264".decodeHex()).write(bytes, 0, 100)
    data.write("8064".decodeHex()).write(bytes, 100, 100)
    clientReader.processNextFrame()
    callback.assertBinaryMessage(bytes)
  }

  @Test fun twoFrameNotContinuation() {
    val bytes = binaryData(200)
    data.write("0264".decodeHex()).write(bytes, 0, 100)
    data.write("8264".decodeHex()).write(bytes, 100, 100)

        then:
        skipped ":write"
        with(origin(":write")) {
            buildInvocationId == thirdBuildId
            buildCacheKey == thirdBuildCacheKey
        }

        when:
        succeeds  "write"

        then:
        skipped ":write"
        originBuildInvocationId(":write") == thirdBuildId

        when:
        succeeds  "write"

        then: