{SHA256WithRSAPSS, "SHA256-RSAPSS", oidSignatureRSAPSS, pssParametersSHA256, RSA, crypto.SHA256, true},
	{SHA384WithRSAPSS, "SHA384-RSAPSS", oidSignatureRSAPSS, pssParametersSHA384, RSA, crypto.SHA384, true},
	{SHA512WithRSAPSS, "SHA512-RSAPSS", oidSignatureRSAPSS, pssParametersSHA512, RSA, crypto.SHA512, true},

        writes1.size() == 20
        writes1[0].details.location == m1.artifact.uri.toString()
        writes1[0].result.bytesWritten == m1.artifact.file.length()

        def reads1 = buildOperations.all(ExternalResourceReadBuildOperationType)
        reads1.size() == 1

        when:
        // Publish again
        buildFile << """
            version = '1.3'
"""

        def m2 = repo.module("org.test", "test", "1.3")

Roland Shoemaker <******@****.***> 1715710936 -0700

Roland Shoemaker <******@****.***> 1715710936 -0700

    /**
     * Reads a nullable string value. Can reads any value that was written using {@link Encoder#writeNullableString(CharSequence)}.
     *
     * @throws EOFException when the end of the byte stream is reached before the string can be fully read.
     */
    @Nullable
    String readNullableString() throws EOFException, IOException;

    /**

      if (is_cpu_read) reads.push_back(read);
    }
  }
  return success();
}

// Move reads above the `replicate`. Skip reads that come after a write to the
// same resource.
void MoveReads(ReplicateOp replicate,
               llvm::SmallVector<ReadVariableOp, 4>& reads) {
  for (ReadVariableOp read : reads) {
    Value res = read.getResource();

`TryRead` and `TryWrite` are still available for non-blocking reads and writes.

To signify the end of the stream, close the ring buffer from the writer side with `rb.CloseWriter()`

Either side can use `rb.CloseWithError(err error)` to signal an error and close the ring buffer. 
Any reads or writes will return the error on next call.

    @Override
    Class<? extends AbstractEncoder> getEncoder() {
        return super.getEncoder()
    }

    def "reads and writes empty snapshots"() {
        when:
        def out = serialize(EMPTY, serializer)

        then:
        out == EMPTY
    }

    def "reads and writes file snapshots"() {

// that provides an optimized implementation of [ReadFile].
type ReadFileFS interface {
	FS

	// ReadFile reads the named file and returns its contents.
	// A successful call returns a nil error, not io.EOF.
	// (Because ReadFile reads the whole file, the expected EOF
	// from the final Read is not treated as an error to be reported.)
	//
	// The caller is permitted to modify the returned byte slice.

	_, err = io.ReadFull(f, dst)
	return dst, st, err
}

// ReadFile reads the named file and returns the contents.
// A successful call returns err == nil, not err == EOF.
// Because ReadFile reads the whole file, it does not treat an EOF from Read
// as an error to be reported.
//
// passes NOATIME flag for reads on Unix systems to avoid atime updates.
func ReadFile(name string) ([]byte, error) {