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

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

### 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,

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.brotli

import okhttp3.Interceptor
import okhttp3.Response
import okhttp3.brotli.internal.uncompress

/**
 * Transparent Brotli response support.
 *
 * Adds Accept-Encoding: br to request and checks (and strips) for Content-Encoding: br in

		b.Fatalf("test file has no data")
	}

	getInputBuf := func(buf []byte, n int) []byte {
		compressed := new(bytes.Buffer)
		w := NewWriter(compressed, LSB, 8)
		for i := 0; i < n; i += len(buf) {
			if len(buf) > n-i {
				buf = buf[:n-i]
			}
			w.Write(buf)
		}
		w.Close()
		return compressed.Bytes()
	}

	for e := 4; e <= 6; e++ {
		n := int(math.Pow10(e))

    /**
     * Creates resource that points to a gzip compressed file at the given path.
     * The path is evaluated as per {@link Project#file(Object)}.
     *
     * @param path The path evaluated as per {@link Project#file(Object)}.
     * @since 7.0
     */
    ReadableResource gzip(Object path);

    /**
     * Creates resource that points to a bzip2 compressed file at the given path.

     * Note that the file returned by this method may not necessarily have the same contents as the resource. For example, the file may be compressed,
     * contain text encoded with a different encoding or represent a directory.
     *
     * @return A file location this resource. Returns null if this resource is not available as a file.
     */
    @Nullable

	// lower 12 bits of a valid entry must be a non-literal code.
	invalidEntry = 0
)

// Writer is an LZW compressor. It writes the compressed form of the data
// to an underlying writer (see [NewWriter]).
type Writer struct {
	// w is the writer that compressed bytes are written to.
	w writer
	// litWidth is the width in bits of literal codes.
	litWidth uint
	// order, write, bits, nBits and width are the state for

        when:
        sourceDir.file("newdir").createDir()

        then:
        buildTriggeredAndSucceeded()
        executedAndNotSkipped(":zip")
    }

    def "using compressed files as inputs - #type #packType #source - readonly #readonly"() {
        given:
        def packDir = file("pack").createDir()
        def outputDir = file("unpack")
        def sourceFile = file(source)

	if n != len(b) || err != nil {
		t.Fatalf("ReadFull(buf) = %d, %s", n, err)
	}

	var z bytes.Buffer
	f, _ := flate.NewWriter(&z, 5)
	f.Write(b)
	f.Close()
	if z.Len() < len(b)*99/100 {
		t.Fatalf("Compressed %d -> %d", len(b), z.Len())
	}
}

func TestReadEmpty(t *testing.T) {
	n, err := Reader.Read(make([]byte, 0))
	if n != 0 || err != nil {
		t.Fatalf("Read(make([]byte, 0)) = %d, %v", n, err)
	}

 * limitations under the License.
 */

package org.gradle.api.internal.file.archive;

import java.io.Closeable;
import java.io.File;

/**
 * A coordinator that can be used to manage access to decompressed data extracted from archive files like zip and tars.
 *
 * <p>
 * For a given build tree, only a single process is allowed write access to extract archives at a time.
 *