Austin Clements <******@****.***> 1449076829 -0500

Austin Clements <******@****.***> 1449076829 -0500

Harshavardhana <******@****.***> 1716837466 -0700

	f.Fuzz(func(t *testing.T, b []byte) {
		cmd := exec.Command(zstd, "-z")
		cmd.Stdin = bytes.NewReader(b)
		var compressed bytes.Buffer
		cmd.Stdout = &compressed
		cmd.Stderr = os.Stderr
		if err := cmd.Run(); err != nil {
			t.Errorf("running zstd failed: %v", err)
		}

		r := NewReader(bytes.NewReader(compressed.Bytes()))
		got, err := io.ReadAll(r)
		if err != nil {
			t.Fatal(err)
		}
		if !bytes.Equal(got, b) {

// so this test only runs on systems with zstd installed.
func TestLarge(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping expensive test in short mode")
	}

	data := bigData(t)
	compressed := zstdBigData(t)

	t.Logf("zstd compressed %d bytes to %d", len(data), len(compressed))

	r := NewReader(bytes.NewReader(compressed))
	got, err := io.ReadAll(r)

    }

    def "reports broken bzip2 file when attempting to read"() {
        def file = file('compressed')
        file.text = "not compressed"

        buildFile << """
def resource = resources.bzip2("compressed")

task show {
    doLast {
        resource.read()
    }
}
"""

        when:
        fails "show"

        then:

            def artifactType = Attribute.of('artifactType', String)
            def compressed = Attribute.of('compressed', Boolean)

            dependencies {
                attributesSchema {
                    attribute(compressed)
                }
                artifactTypes {
                    zip {
                        attributes.attribute(compressed, true)
                    }
                }
            }

	z := new(Writer)
	z.init(w, level)
	return z, nil
}

func (z *Writer) init(w io.Writer, level int) {
	compressor := z.compressor
	if compressor != nil {
		compressor.Reset(w)
	}
	*z = Writer{
		Header: Header{
			OS: 255, // unknown
		},
		w:          w,
		level:      level,
		compressor: compressor,
	}
}

// Reset discards the [Writer] z's state and makes it equivalent to the

### 4. Excluded Types

- Already compressed objects are not fit for compression since they do not have compressible patterns.
Such objects do not produce efficient [`LZ compression`](https://en.wikipedia.org/wiki/LZ77_and_LZ78)
which is a fitness factor for a lossless data compression.

Pre-compressed input typically compresses in excess of 2GiB/s per core,

    def "can read from bzip2 file"() {
        def sourceFile = testDirectory.file("source")
        def compressedFile = testDirectory.file("compressed")
        sourceFile.text = "hello"
        sourceFile.bzip2To(compressedFile)

        buildFile << """
def resource = resources.bzip2("compressed")

task show {
    doLast {
        def stream = resource.read()
        try { println stream.text } finally { stream.close() }
    }