byte[] largeBuffer = new byte[1024];

            int encoded = context.encode(largeBuffer, 0);
            assertEquals(2 + 200, encoded); // 2 for count + 100*2 for ciphers

            EncryptionNegotiateContext decoded = new EncryptionNegotiateContext();
            try {
                int decodedSize = decoded.decode(largeBuffer, 0, encoded);

    }

    @Test
    @DisplayName("Test readSetupWireFormat returns 0")
    void testReadSetupWireFormat() {
        byte[] buffer = new byte[100];
        int result = response.readSetupWireFormat(buffer, 0, 100);
        assertEquals(0, result);

        // Test with different parameters
        result = response.readSetupWireFormat(buffer, 10, 50);
        assertEquals(0, result);
    }

    @Test

        val delays = mutableListOf(50.µs, -1L)

        override fun runOnce(): Long {
          log += "run@${taskFaker.nanoTime}"
          redQueue.cancelAll()
          return delays.removeAt(0)
        }
      },
      100.µs,
    )

    taskFaker.advanceUntil(0.µs)
    assertThat(log).isEmpty()

    taskFaker.advanceUntil(100.µs)
    assertThat(log).containsExactly("run@100000")

        return clearText;
    }

    // Tables, permutations, S-boxes, etc.

    private static byte[] bytebit =
            { (byte) 0x80, (byte) 0x40, (byte) 0x20, (byte) 0x10, (byte) 0x08, (byte) 0x04, (byte) 0x02, (byte) 0x01 };
    private static int[] bigbyte = { 0x800000, 0x400000, 0x200000, 0x100000, 0x080000, 0x040000, 0x020000, 0x010000, 0x008000, 0x004000,

        // ... rest of first entry fields (zeros for simplicity)
        for (int i = 16; i < 102; i++) {
            buffer[i] = 0;
        }
        SMBUtil.writeInt4(8, buffer, 68); // FileNameLength at offset 60 from start
        byte[] file1 = "file1".getBytes(StandardCharsets.UTF_16LE);
        System.arraycopy(file1, 0, buffer, 102, file1.length);

        // Write second FileBothDirectoryInfo at 8 + 104 = 112

    private static final int TEST_CAPABILITIES = 0x00000001;
    private static final long TEST_PREVIOUS_SESSION_ID = 0x1234567890ABCDEFL;
    private static final byte[] TEST_TOKEN = { 0x01, 0x02, 0x03, 0x04, 0x05 };

    @BeforeEach
    void setUp() {
        mockConfig = mock(Configuration.class);
        mockContext = mock(CIFSContext.class);
        when(mockContext.getConfig()).thenReturn(mockConfig);

	CADDI4SPN $4, X5, X10				// ERROR "SP/X2 must be in rs1"
	CADDI4SPN $-1, SP, X10				// ERROR "must be in range [0, 1023]"
	CADDI4SPN $0, SP, X10				// ERROR "immediate cannot be zero"
	CADDI4SPN $6, SP, X10				// ERROR "must be a multiple of 4"
	CADDI4SPN $1024, SP, X10			// ERROR "must be in range [0, 1023]"
	CSLLI	$63, X5, X6				// ERROR "rd must be the same as rs1"
	CSLLI	$-1, X5					// ERROR "must be in range [0, 63]"

        range = VersionRange.createFromVersionSpec("[1.0,1.1-SNAPSHOT]");
        assertTrue(range.containsVersion(new DefaultArtifactVersion("1.1-SNAPSHOT")));

        range = VersionRange.createFromVersionSpec("[5.0.9.0,5.0.10.0)");
        assertTrue(range.containsVersion(new DefaultArtifactVersion("5.0.9.0")));
    }

    @Test
    void testSameUpperAndLowerBoundRoundtrip() throws InvalidVersionSpecificationException {

   * prefix, or when one array is a prefix of the other, treats the shorter array as the lesser. For
   * example, {@code [] < [0x01] < [0x01, 0x7F] < [0x01, 0x80] < [0x02]}. Values are treated as
   * unsigned.
   *
   * <p>The returned comparator is inconsistent with {@link Object#equals(Object)} (since arrays
   * support only identity equality), but it is consistent with {@link

		return
	}

	const mapEntryOverhead = 200

	var (
		reader        io.Reader
		actualSize    int64 = -1
		fileName      string
		fanOutEntries = make([]minio.PutObjectFanOutEntry, 0, 100)
	)

	maxParts := 1000
	// Canonicalize the form values into http.Header.
	formValues := make(http.Header)
	var headerLen int64
	for {
		part, err := mp.NextRawPart()
		if errors.Is(err, io.EOF) {