// Then: Should use trans1 (addr2 failed, so tried addr1 next)
        assertSame(trans1, result);

        // Verify fail count incremented for addr2 (was 1, now 2)
        assertEquals(2, poolSpy.failCounts.get("10.0.0.2"));
        // addr1's count should remain unchanged since it succeeded
        assertEquals(5, poolSpy.failCounts.get("10.0.0.1"));
    }

///

## Reduce duplication { #reduce-duplication }

Reducing code duplication is one of the core ideas in **FastAPI**.

As code duplication increments the chances of bugs, security issues, code desynchronization issues (when you update in one place but not in the others), etc.

And these models are all sharing a lot of the data and duplicating attribute names and types.

Este código é algo que você pode realmente usar na sua aplicação, salvar os hashes das senhas no seu banco de dados, etc.

Vamos começar de onde paramos no capítulo anterior e incrementá-lo.

## Sobre o JWT

JWT significa "JSON Web Tokens".

É um padrão para codificar um objeto JSON em uma string longa e densa sem espaços. Ele se parece com isso:

```

        }

        /*
         * The message provided to batch has a batchLimit that is
         * higher than the current batchLevel so we will now encode
         * that chained message. Before doing so we must increment
         * the batchLevel of the andx message in case it itself is an
         * andx message and needs to perform the same check as above.
         */

        this.andx.batchLevel = this.batchLevel + 1;

This code is something you can actually use in your application, save the password hashes in your database, etc.

We are going to start from where we left in the previous chapter and increment it.

## About JWT { #about-jwt }

JWT means "JSON Web Tokens".

It's a standard to codify a JSON object in a long dense string without spaces. It looks like this:

```

         */
        public synchronized void updateState(int newState) {
            this.leaseState = newState;
            this.lastAccessTime = System.currentTimeMillis();
        }

        /**
         * Increment the epoch value
         */
        public synchronized void incrementEpoch() {
            this.epoch++;
        }

        /**
         * Check if lease has read caching
         *

        int counter1 = buffer1.getInt();
        int counter2 = buffer2.getInt();

        assertEquals(counter1 + 1, counter2, "Counter should increment between nonces");
    }

    @Test
    @DisplayName("Should generate secure random nonces when requested")
    void testSecureNonceGeneration() {
        // Given

        if (sessionKey == null) {
            throw new GeneralSecurityException("Session key not available for automatic rotation");
        }

        // Increment rotation counter for tracking and key derivation
        rotationCount++;

        // SMB3-compliant key rotation: Use rotation counter as per SMB3 specification