package okhttp3.internal.concurrent

/**
 * A unit of work that can be executed one or more times.
 *
 * Recurrence
 * ----------
 *
 * Tasks control their recurrence schedule. The [runOnce] function returns -1L to signify that the
 * task should not be executed again. Otherwise it returns a delay until the next execution.
 *
 * A task has at most one next execution. If the same task instance is scheduled multiple times, the

 *
 * <p><b>Warning:</b> The caller is responsible for not attempting to read past the end of the
 * array. If any method encounters the end of the array prematurely, it throws {@link
 * IllegalStateException} to signify <i>programmer error</i>. This behavior is a technical violation
 * of the supertype's contract, which specifies a checked exception.
 *
 * @author Kevin Bourrillion
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible

    @Override
    public boolean isMICAvailable() {
        return !this.auth.isGuest() && this.signKey != null && this.verifyKey != null;
    }

    @Override
    public byte[] calculateMIC(final byte[] data) throws CIFSException {
        final byte[] sk = this.signKey;
        if (sk == null) {
            throw new CIFSException("Signing is not initialized");
        }

    /**
     * Checks whether the server has SMB message signing enabled.
     *
     * @return whether the server has signing enabled
     */
    boolean isSigningEnabled();

    /**
     * Checks whether the server requires SMB message signing.
     *
     * @return whether the server requires signing
     */
    boolean isSigningRequired();

    /**

        // Then
        assertNotNull(signingKey, "Signing key should not be null");
        assertEquals(16, signingKey.length, "Signing key should be 16 bytes");
        assertFalse(Arrays.equals(sessionKey, signingKey), "Signing key should be different from session key");
    }

    @Test
    @DisplayName("Should derive signing key for SMB 3.1.1 dialect")
    void testDeriveSigningKey_SMB311() {
        // Given

     */
    int encode(byte[] dst, int dstIndex);

    /**
     * Sets the signing digest for this message.
     *
     * @param digest the signing digest to set
     */
    void setDigest(SMBSigningDigest digest);

    /**
     * Gets the signing digest for this message.
     *
     * @return the signing digest
     */
    SMBSigningDigest getDigest();

    /**

import jcifs.internal.SMBSigningDigest;
import jcifs.internal.util.SMBUtil;
import jcifs.util.Crypto;

/**
 * SMB2/SMB3 message signing digest implementation.
 *
 * This class handles cryptographic signing of SMB2/SMB3 messages to ensure
 * message integrity and authenticity. It supports different signing algorithms
 * used in various SMB2/SMB3 dialect versions.
 *
 * @author mbechler
 */

    private boolean bypass = false;
    private int updates;
    private int signSequence;

    /**
     * Constructs a new signing digest with the specified MAC signing key.
     *
     * @param macSigningKey the MAC signing key for message authentication
     * @param bypass whether to bypass MAC signing
     * @throws SmbException if MD5 algorithm is not available
     */

 * with the server, including security requirements like message signing.
 *
 * @author mbechler
 */
public interface SmbNegotiationRequest {

    /**
     * Checks whether SMB message signing is enforced by the client.
     *
     * @return whether SMB signing is enforced
     */
    boolean isSigningEnforced();

        assertTrue(context.isEstablished());
        assertArrayEquals(serverChallenge, context.getServerChallenge());
        // Signing key may or may not be generated depending on flags negotiation
        // The context negotiates flags with server, so we can't guarantee signing key
    }

    @Test
    void testInitSecContext_state2_withoutSigning() throws Exception {