assertHashStringWithSurrogatesEquivalence(hashFunction, random);
    }
  }

  private static void assertHashBytesEquivalence(HashFunction hashFunction, Random random) {
    int size = random.nextInt(2048);
    byte[] bytes = new byte[size];
    random.nextBytes(bytes);
    assertEquals(
        hashFunction.hashBytes(bytes), hashFunction.newHasher(size).putBytes(bytes).hash());
    int off = random.nextInt(size);

	ADDI	$2047, X5				// 9382f27f
	ADDI	$-2048, X5				// 93820280
	ADDI	$2048, X5				// 9382024093820240
	ADDI	$-2049, X5				// 938202c09382f2bf
	ADDI	$4094, X5				// 9382f27f9382f27f
	ADDI	$-4096, X5				// 9382028093820280
	ADDI	$4095, X5				// b71f00009b8fffffb382f201
	ADDI	$-4097, X5				// b7ffffff9b8fffffb382f201
	ADDI	$2047, X5, X6				// 1383f27f
	ADDI	$-2048, X5, X6				// 13830280

        keySize = 256
      }

    /**
     * Configure the certificate to generate a 2048-bit RSA key, which provides about 112 bits of
     * security. RSA keys are interoperable with very old clients that don't support ECDSA.
     */
    fun rsa2048() =
      apply {
        keyAlgorithm = "RSA"
        keySize = 2048
      }

    fun build(): HeldCertificate {
      // Subject keys & identity.

            standardInfo.endOfFile = 2048L;
            standardInfo.numberOfLinks = 1;

            String str = standardInfo.toString();

            assertNotNull(str);
            assertTrue(str.contains("SmbQueryInfoStandard"));
            assertTrue(str.contains("allocationSize=4096"));
            assertTrue(str.contains("endOfFile=2048"));
        }
    }

    @Nested

| :--           | :--                                            |
| *Type*        | *String*                                       |
| *Valid Range* | *Minimum length of 1. Maximum length of 2048.* |
| *Required*    | *No*                                           |

### Response Elements

		{data2[:1536] + trash[:511], 1, io.ErrUnexpectedEOF},
		{data2[:1536] + trash, 1, ErrHeader},
		{data2[:2048], 1, io.EOF}, // Exactly 1 empty block
		{data2[:2048] + trash[:1], 1, io.ErrUnexpectedEOF},
		{data2[:2048] + trash[:511], 1, io.ErrUnexpectedEOF},
		{data2[:2048] + trash, 1, ErrHeader},
		{data2[:2560], 1, io.EOF}, // Exactly 2 empty blocks (normal end-of-stream)
		{data2[:2560] + trash[:1], 1, io.EOF},

package bpool

import (
	"testing"
)

// Tests - bytePool functionality.
func TestBytePool(t *testing.T) {
	size := uint64(4)
	width := 1024
	capWidth := 2048

	bp := NewBytePoolCap(size, width, capWidth)

	// Check the width
	if bp.Width() != width {
		t.Fatalf("bytepool width invalid: got %v want %v", bp.Width(), width)
	}

	// Check with width cap

    void testReadBytesWireFormatVariousDataLengths(int dataLength, int dataRemaining) throws Exception {
        // Given
        byte[] largeBuffer = new byte[2048];
        byte[] largeOutputBuffer = new byte[2048];
        Smb2ReadResponse largeResponse = new Smb2ReadResponse(mockConfig, largeOutputBuffer, 0);

        int bodyStart = 0;
        int dataOffsetFromHeader = 80;

        dnsDomainInfo.sid.sub_authority_count = 1;
        dnsDomainInfo.sid.sub_authority = new int[] { 21 };

        // Encode to buffer
        byte[] buffer = new byte[2048];
        NdrBuffer encodeBuffer = new NdrBuffer(buffer, 0);
        dnsDomainInfo.encode(encodeBuffer);

        // Decode from buffer
        NdrBuffer decodeBuffer = new NdrBuffer(buffer, 0);

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

### WebIdentityAccessToken (MinIO Extension)