A testing library for Go programs.

Package quartz is a library for testing time related code. It exports an interface Clock that mimics the standard library time package functions. In production, an implementation that calls thru to the standard library is used. In testing, a Mock clock is used to precisely control and intercept time functions.

clock is a small library for mocking time in Go. It provides an interface around the standard library's time package so that the application can use the realtime clock while tests can use the mock clock.

gotestspace is used to quickly create a working directory for shell execution using Go, as well as a tool for customizing the execution of the shell. It can help you quickly create an independent workspace for unit testing and improve the efficiency of unit test writing.

Versatile HTTP mocking made easy in Go that works with any net/http based stdlib implementation. Inspired by the Node nock library, it has features like:

• Simple and expressive API

• Semantic API DSL for declarative HTTP mock declarations

• Built-in helpers for easy JSON/XML mocking

• Supports persistent and volatile TTL-limited mocks

• Full regular expressions capable HTTP request mock matching

• Designed for both testing and runtime scenarios

• Match request by method, URL params, headers and bodies

• Extensible and pluggable HTTP matching rules

• Ability to switch between mock and real networking modes

• Ability to filter/map HTTP requests for accurate mock matching

• Supports map and filters to handle mocks easily

• Wide compatible HTTP interceptor using http.RoundTripper interface

• Works with any net/http compatible client, such as gentleman

• Network timeout/cancellation delay simulation

• Extensible and hackable API

This package provide a Go analyzer that detects using os.Setenv instead of t.Setenv since Go1.17.

This package is a linter that detects struct contained context.Context field. This is discouraged technique in favour of passing context as first argument of method or function. For rationale please read Contexts and structs the Go blog post.

compress provides various compression algorithms.

MinLZ is a LZ77-type compressor with a fixed byte-aligned encoding, in the similar class to Snappy and LZ4.

This package provides an implementation of the LZO1X decompression algorithm in Go. The implementation is derived from the Linux kernel documentation for the LZO stream format and the implementation from lzokay project (MIT licensed). It includes a Reader for streaming decompressed data and a standalone Decompress function for use with byte slices.

This package implements a native XZ decompression in Golang.

This package provides a support of reading and writing of xz compressed streams. It includes also a gxz command for compressing and decompressing data. The package is completely written in Go and doesn't have any dependency on any C code.

This package provides a library for reading RAR archives with Golang.

This package is an implementation of Roaring bitmaps as described at https://roaringbitmap.org/about/ in Go. Roaring bitmaps are fast compressed bitmap data structures (also called bitset). They are ideally suited to represent sets of integers over relatively small ranges.

This package provides an enhanced version of the compress/lzw library included in the stdlib, and supports GIF, TIFF and PDF.

This packages provides a seekable ZSTD compression format implemented in Golang. It is a random access reader (using uncompressed file offsets) for ZSTD-compressed streams. This can be used for creating transparent compression layers. Coupled with Content Defined Chunking (CDC) it can also be used as a robust de-duplication layer. It is an alternative fork of https://github.com/SaveTheRbtz/zstd-seekable-format-go.

Package xz implements XZ decompression natively in Go.

This package implements reader/writer library eStargz - a lazily-pullable image format.

Package archiver facilitates convenient, cross-platform, high-level archival and compression operations for a variety of formats and compression algorithms.

Features:

• stream-oriented APIs

• automatically identify archive and compression formats

• traverse directories, archive files, and any other file uniformly as io/fs file systems

• compress and decompress files

• create and extract archive files

• walk or traverse into archive files

• extract only specific files from archives

• insert (append) into .tar and .zip archives

• read from password-protected 7-Zip files

• numerous archive and compression formats supported

• extensible (add more formats just by registering them)

• cross-platform, static binary

• pure Golang (no cgo)

• multithreaded Gzip

• adjust compression levels

• automatically add compressed files to zip archives without re-compressing

• open password-protected rar archives

Supported compression formats:

• brotli (.br)

• bzip2 (.bz2)

• flate (.zip)

• gzip (.gz)

• lz4 (.lz4)

• lzip (.lz)

• snappy (.sz)

• xz (.xz)

• zlib (.zz)

• zstandard (.zst)

Supported archive formats:

• .zip

• .tar (including any compressed variants like .tar.gz)

• .rar (read-only)

• .7z (read-only)

This package implements parallel gzip compression and decompression in Golang and is fully compatible with compress/gzip from the standard library. This is beneficial for large amounts of data, say more than 1MB at a time, as otherwise the internal gzip library will likely be faster.

This package provides a Go wrapper to zstd C library.

lz4 provides a streaming interface to LZ4 data streams as well as low level compress and uncompress functions for LZ4 data blocks. The implementation is based on the reference C one.

This package provides a Go implementation of the Snappy compression format.

Package extract allows to extract archives in zip,tar.gz or tar.bz2 formats easily.