}

  // Static factories

  /**
   * Creates a {@code Striped<L>} with eagerly initialized, strongly referenced locks. Every lock is
   * obtained from the passed supplier.
   *
   * @param stripes the minimum number of stripes (locks) required
   * @param supplier a {@code Supplier<L>} object to obtain locks from
   * @return a new {@code Striped<L>}
   */
  static <L> Striped<L> custom(int stripes, Supplier<L> supplier) {

    * objetos JSON (`dict`).
    * arrays JSON (`list`), definindo tipos dos itens.
    * campos String (`str`), definindo tamanho mínimo e máximo.
    * Numbers (`int`, `float`) com valores mínimos e máximos, etc.

* Validação de tipos mais exóticos, como:
    * URL.
    * Email.
    * UUID.
    * ...e outros.

 */
interface PushObserver {
  /**
   * Describes the request that the server intends to push a response for.
   *
   * @param streamId server-initiated stream ID: an even number.
   * @param requestHeaders minimally includes `:method`, `:scheme`, `:authority`,
   * and `:path`.
   */
  fun onRequest(
    streamId: Int,
    requestHeaders: List<Header>,
  ): Boolean

  /**

| :--                  | :--                                            |
| *Type*               | *String*                                       |
| *Length Constraints* | *Minimum length of 4. Maximum length of 2048.* |
| *Required*           | *Yes*                                          |

### Version

  /**
   * Returns the minimum value of type {@code C}, if it has one. The minimum value is the unique
   * value for which {@link Comparable#compareTo(Object)} never returns a positive value for any
   * input of type {@code C}.
   *
   * <p>The default implementation throws {@code NoSuchElementException}.
   *
   * @return the minimum value of type {@code C}; never null

  /**
   * Returns the minimum value of type {@code C}, if it has one. The minimum value is the unique
   * value for which {@link Comparable#compareTo(Object)} never returns a positive value for any
   * input of type {@code C}.
   *
   * <p>The default implementation throws {@code NoSuchElementException}.
   *
   * @return the minimum value of type {@code C}; never null

			t.Errorf("Test %d: Expected %t, got %t", i+1, s.isMax, isMax)
		}
	}
}

// Tests minimum allowed part size.
func TestMinAllowedPartSize(t *testing.T) {
	sizes := []struct {
		isMin bool
		size  int64
	}{
		// Test - 1 - within minimum part size.
		{
			true,
			globalMinPartSize + 1,
		},
		// Test - 2 - smaller than minimum part size.
		{
			false,
			globalMinPartSize - 1,
		},
	}

     */
    double estimateCompressionRatio(byte[] data, int algorithm);

    /**
     * Gets the minimum data size threshold for compression.
     * Data smaller than this threshold should not be compressed.
     *
     * @return minimum size in bytes for compression to be beneficial
     */
    int getMinCompressionSize();

    /**

        }
    }

    @Test
    @DisplayName("Test decode with minimum valid length")
    void testDecodeMinimumValidLength() throws SMBProtocolDecodingException {
        // Prepare minimum valid buffer - exactly 24 bytes
        byte[] buffer = new byte[28];
        Arrays.fill(buffer, 0, 24, (byte) 0xAA);

        // Decode with len = 24 (minimum valid)
        int bytesConsumed = response.decode(buffer, 0, 24);

    @Test
    @DisplayName("Test context encoding")
    public void testEncoding() {
        byte[] buffer = new byte[256];
        int encodedSize = context.encode(buffer, 0);

        assertTrue(encodedSize > 8); // Minimum size: count + padding + flags + algorithms
        assertEquals(context.size(), encodedSize);
    }

    @Test
    @DisplayName("Test context decoding")
    public void testDecoding() throws SMBProtocolDecodingException {