*/
    public int[] getHashAlgos() {
        return this.hashAlgos;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.nego.NegotiateContextRequest#getContextType()
     */
    @Override
    public int getContextType() {
        return NEGO_CTX_PREAUTH_TYPE;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override

            EncryptionNegotiateContext encryption = new EncryptionNegotiateContext();

            assertNotEquals(preauth.getContextType(), encryption.getContextType());
            assertEquals(0x1, preauth.getContextType());
            assertEquals(0x2, encryption.getContextType());
        }

        @Test
        @DisplayName("Should verify all implementations are NegotiateContextRequest")

 * @author mbechler
 */
public interface NegotiateContextRequest extends Encodable {

    /**
     * Gets the negotiate context type.
     *
     * @return the SMB2 negotiate context type
     */
    int getContextType();

 * @author mbechler
 */
public interface NegotiateContextResponse extends Decodable {

    /**
     * Gets the negotiate context type.
     *
     * @return the SMB2 negotiate context type
     */
    int getContextType();

     * Default constructor for response parsing.
     */
    public CompressionNegotiateContext() {
        this.compressionAlgorithms = new int[0];
        this.flags = 0;
    }

    @Override
    public int getContextType() {
        return NEGO_CTX_COMPRESSION_TYPE;
    }

    /**
     * Gets the supported compression algorithms.
     *
     * @return the supported compression algorithms
     */

            assertTrue(encContext instanceof NegotiateContextResponse);
            assertEquals(PreauthIntegrityNegotiateContext.NEGO_CTX_PREAUTH_TYPE, preauthContext.getContextType());
            assertEquals(EncryptionNegotiateContext.NEGO_CTX_ENC_TYPE, encContext.getContextType());
        }

        @Test
        @DisplayName("Should be able to use polymorphically")
        void testPolymorphicUsage() {
            // Arrange

                this.supportsEncryption = true;
            } else if (ncr.getContextType() == EncryptionNegotiateContext.NEGO_CTX_ENC_TYPE) {
                log.debug("Multiple encryption negotiate contexts");
                return false;
            } else if (!foundPreauth && ncr.getContextType() == PreauthIntegrityNegotiateContext.NEGO_CTX_PREAUTH_TYPE) {
                foundPreauth = true;

    }

    @Test
    @DisplayName("Test compression context type")
    public void testContextType() {
        assertEquals(CompressionNegotiateContext.NEGO_CTX_COMPRESSION_TYPE, context.getContextType());
    }

    @Test
    @DisplayName("Test supported algorithms")
    public void testSupportedAlgorithms() {
        int[] algorithms = context.getCompressionAlgorithms();
        assertNotNull(algorithms);

            PreauthIntegrityNegotiateContext context = new PreauthIntegrityNegotiateContext();

            assertEquals(PreauthIntegrityNegotiateContext.NEGO_CTX_PREAUTH_TYPE, context.getContextType());
            assertEquals(0x1, context.getContextType());
        }
    }

    @Nested
    @DisplayName("Encoding Tests")
    class EncodingTests {

        @Test

            SMBUtil.writeInt4(dstIndex - getHeaderStart(), dst, negotitateContextOffsetOffset);
            for (final NegotiateContextRequest nc : this.negotiateContexts) {
                SMBUtil.writeInt2(nc.getContextType(), dst, dstIndex);
                final int lenOffset = dstIndex + 2;
                dstIndex += 4;
                SMBUtil.writeInt4(0, dst, dstIndex);
                dstIndex += 4; // Reserved