*/
package jcifs.smb.compression;

import jcifs.CIFSException;

/**
 * Interface for SMB3 compression services.
 *
 * Provides compression and decompression functionality for SMB3 protocol
 * data transfers with support for multiple compression algorithms.
 */
public interface CompressionService {

    /**
     * Compression algorithm constants matching SMB3 specification.
     */

        byte[] decompressed = compressionService.decompress(compressed, CompressionService.COMPRESSION_NONE);
        assertArrayEquals(testData, decompressed);
    }

    @Test
    @DisplayName("Test LZ77 compression and decompression")
    public void testLZ77Compression() throws CIFSException {
        byte[] compressed = compressionService.compress(testData, CompressionService.COMPRESSION_LZ77);
        assertNotNull(compressed);

        case COMPRESSION_LZNT1:
            throw new CIFSException("LZNT1 decompression not yet implemented");

        case COMPRESSION_PATTERN_V1:
            throw new CIFSException("Pattern_V1 decompression not yet implemented");

        default:
            throw new CIFSException("Unknown compression algorithm: " + algorithm);
        }
    }

    @Override

      decompress(response)
    } else {
      chain.proceed(chain.request())
    }

  /**
   * Returns a decompressed copy of the Response, typically via a streaming Source.
   * If no known decompression or the response is not compressed, returns the response unmodified.
   */
  internal fun decompress(response: Response): Response {
    if (!response.promisesBody()) {
      return response
    }

# Compression Guide [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)

MinIO server allows streaming compression to ensure efficient disk space usage.
Compression happens inflight, i.e objects are compressed before being written to disk(s).
MinIO uses [`klauspost/compress/s2`](https://github.com/klauspost/compress/tree/master/s2)
streaming compression due to its stability and performance.

        assertEquals(testData, new String(decompressed));
        // For small strings, gzip overhead might make compressed data larger
        // So we just verify that compression/decompression works correctly
        assertNotNull(compressed);
        assertTrue(compressed.length > 0);
    }

    // Helper methods for creating mock objects
    private SearchRequestParams createMockSearchRequestParams() {

    memory if web socket compression is negotiated but not used.


## Version 4.5.0-RC1

_2020-03-17_

**This release candidate turns on web socket compression.**

The [spec][rfc_7692] includes a sophisticated mechanism for client and server to negotiate
compression features. We strive to offer great performance in our default configuration and so we're

func (o *ObjectInfo) IsCompressed() bool {
	_, ok := o.UserDefined[ReservedMetadataPrefix+"compression"]
	return ok
}

// IsCompressedOK returns whether the object is compressed and can be decompressed.
func (o *ObjectInfo) IsCompressedOK() (bool, error) {
	scheme, ok := o.UserDefined[ReservedMetadataPrefix+"compression"]
	if !ok {
		return false, nil
	}
	switch scheme {

				NewPutObjReader(hr),
				ObjectOptions{
					PreserveETag: part.ETag, // Preserve original ETag to ensure same metadata.
					IndexCB: func() []byte {
						return part.Index // Preserve part Index to ensure decompression works.
					},
					NoAuditLog: true,
				})
			if err != nil {
				return fmt.Errorf("rebalanceObject: PutObjectPart() %w", err)
			}
			parts[i] = CompletePart{
				ETag:       pi.ETag,

        ),
      )
    }
    handler.windowUpdate(streamId, increment)
  }

  @Throws(IOException::class)
  override fun close() {
    source.close()
  }

  /**
   * Decompression of the header block occurs above the framing layer. This class lazily reads
   * continuation frames as they are needed by [Hpack.Reader.readHeaders].
   */
  internal class ContinuationSource(