// Arrange: Build sequence with invalid version and otherwise valid tags
        ASN1EncodableVector v = new ASN1EncodableVector();
        v.add(new DERTaggedObject(true, 0, new ASN1Integer(badPvno))); // wrong pvno
        v.add(new DERTaggedObject(true, 1, new ASN1Integer(Integer.parseInt(KerberosConstants.KERBEROS_AP_REQ))));
        v.add(new DERTaggedObject(true, 2, new DERBitString(new byte[] { 0x00 })));

            IllegalStateException exception = assertThrows(IllegalStateException.class, () -> {
                testRequest.encode(buffer, 0);
            });

            assertTrue(exception.getMessage().contains("Wrong size calculation"));
        }
    }

    // Test implementation classes
    private static class TestServerMessageBlock2Request extends ServerMessageBlock2Request<TestServerMessageBlock2Response> {

            assertThrows(GeneralSecurityException.class, () -> {
                storage2.decryptCredentials(encrypted);
            }, "Should throw GeneralSecurityException when decrypting with wrong salt");
        } finally {
            storage2.close();
        }

        // Clean up
        Arrays.fill(plaintext, '\0');
    }

    @Test

        @Test
        @DisplayName("Should throw exception for invalid structure size")
        void testInvalidStructureSize() {
            byte[] buffer = new byte[64];
            SMBUtil.writeInt2(16, buffer, 0); // Wrong structure size (should be 17)

            assertThrows(SMBProtocolDecodingException.class, () -> {
                response.readBytesWireFormat(buffer, 0);
            }, "Expected structureSize = 17");
        }

        Smb2CreateResponse resp = new Smb2CreateResponse(config, "bad");

        byte[] header = buildSmb2Header();
        byte[] body = new byte[2 + 2 + 4];
        // Wrong structure size (e.g., 0)
        SMBUtil.writeInt2(0, body, 0);
        // The rest of the fields are irrelevant since it should fail early
        byte[] packet = buildPacket(header, body, null, null);

             */

            if (wordCount > 2) {
                readParameterWordsWireFormat(buffer, bufferIndex + 4);

                /* The SMB_COM_NT_CREATE_ANDX response wordCount is wrong. There's an
                 * extra 16 bytes for some "Offline Files (CSC or Client Side Caching)"
                 * junk. We need to bump up the wordCount here so that this method returns

        assertFalse(init.getContextFlag(NegTokenInit.CONFIDENTIALITY));
        assertEquals(NegTokenInit.INTEGRITY, init.getContextFlags());
    }

    @Test
    @DisplayName("Parse rejects wrong SPNEGO OID")
    void testParseRejectsWrongOid() throws Exception {
        byte[] token = buildInitToken(new ASN1ObjectIdentifier[] { OID_KRB }, 0, null, null, false, "1.2.840.113554.1.2.2", // Kerberos OID instead of SPNEGO OID

             */

            if (this.wordCount > 2) {
                readParameterWordsWireFormat(buffer, bufferIndex + 4);

                /*
                 * The SMB_COM_NT_CREATE_ANDX response wordCount is wrong. There's an
                 * extra 16 bytes for some "Offline Files (CSC or Client Side Caching)"
                 * junk. We need to bump up the wordCount here so that this method returns

    @Test
    @DisplayName("Should handle context with null values")
    void testNullContext() {
        // When
        exception = new SmbOperationException(SmbOperationException.ErrorCode.UNKNOWN_ERROR, "Something went wrong", null, null, null);

        // Then
        assertNotNull(exception.getContext());
        assertTrue(exception.getContext().isEmpty());

        // Adding null context should be safe

        // Should validate string length
        String result = unicodeString.check(testString);
        assertEquals(testString, result);

        // Should reject wrong length
        assertThrows(PACDecodingException.class, () -> {
            unicodeString.check("WRONGLENGTH");
        });
    }

    @Test
    @DisplayName("Test empty arrays using mock")