StackTraceElement[] stackTrace = exception.getStackTrace();
        assertNotNull(stackTrace);
        assertTrue(stackTrace.length > 0);

        // The first element should be from this test class
        StackTraceElement firstElement = stackTrace[0];
        assertEquals(this.getClass().getName(), firstElement.getClassName());
    }

    public void test_throwAndCatch() {

        // Given
        when(negotiationRequest.isSigningEnforced()).thenReturn(true).thenReturn(false).thenReturn(true);

        // When & Then
        assertTrue(negotiationRequest.isSigningEnforced(), "First call should return true");
        assertFalse(negotiationRequest.isSigningEnforced(), "Second call should return false");
        assertTrue(negotiationRequest.isSigningEnforced(), "Third call should return true");

        byte[] bufferData = buf.getBuffer();
        assertEquals((byte) 0xCD, bufferData[startIndex + alignmentBytes], "Least significant byte should be first");
        assertEquals((byte) 0x00, bufferData[startIndex + alignmentBytes + 1], "Most significant byte should be second");
    }

    /**
     * When given a buffer with sufficient length, decode performs

 *   <li>Dynamic passwords provided through extraction parameters</li>
 * </ul>
 *
 * <p>Passwords are matched against URLs or resource names using regular expression patterns.
 * The extractor first tries to match against the URL, then falls back to the resource name if available.
 *
 * @author shinsuke
 */
public abstract class PasswordBasedExtractor extends AbstractExtractor {

                (byte) 0x05, (byte) 0x06, (byte) 0x07, (byte) 0x08
              },
              0x89abcdef,
              0x0123456789abcdefL, // asInt/asLong as above, due to equal eight first bytes
              "efcdab89674523010102030405060708"),
          new ExpectedHashCode(
              new byte[] {(byte) 0xdf, (byte) 0x9b, (byte) 0x57, (byte) 0x13},
              0x13579bdf,
              null,

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

    @Test
    public void testDecryptWithWrongSalt() throws Exception {
        char[] plaintext = "TestData".toCharArray();

        // Encrypt with first storage
        byte[] encrypted = storage.encryptCredentials(plaintext);

        // Create new storage with different salt
        SecureCredentialStorage storage2 = new SecureCredentialStorage(masterPassword.clone());

            ASN1Sequence seq = (ASN1Sequence) top.getBaseObject();
            assertEquals(2, seq.size(), "Sequence should contain OID and [0] NegTokenInit");
            assertTrue(seq.getObjectAt(0) instanceof ASN1ObjectIdentifier, "First element should be OID");
            ASN1ObjectIdentifier oid = (ASN1ObjectIdentifier) seq.getObjectAt(0);
            assertEquals(SPNEGO_OID_STR, oid.getId(), "OID should be SPNEGO");
        }
    }

    @Nested

### Normal **FastAPI** { #normal-fastapi }

First, write all your **FastAPI** application as normally:

{* ../../docs_src/extending_openapi/tutorial001.py hl[1,4,7:9] *}

### Generate the OpenAPI schema { #generate-the-openapi-schema }

func freezeServices() {
	// Use atomics for globalServiceFreeze, so we can read without locking.
	// We need a lock since we are need the 2 atomic values to remain in sync.
	globalServiceFreezeMu.Lock()
	// If multiple calls, first one creates channel.
	globalServiceFreezeCnt++
	if globalServiceFreezeCnt == 1 {
		globalServiceFreeze.Store(make(chan struct{}))
	}
	globalServiceFreezeMu.Unlock()
}

.card-footer,.card-group>.card:not(:last-child) .card-img-bottom{border-bottom-right-radius:0}.card-group>.card:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.card-group>.card:not(:first-child) .card-header,.card-group>.card:not(:first-child) .card-img-top{border-top-left-radius:0}.card-group>.card:not(:first-child) .card-footer,.card-group>.card:not(:first-child) .card-img-bottom{border-bottom-left-radius:0}}.card-columns .card{margin-bottom:.75rem}@media (min-width:576p...