// Available if context is established and integrity is supported
            return this.established && this.integrity;
        }
    }

    @Nested
    @DisplayName("Happy path behavior")
    class HappyPath {
        @Test
        @DisplayName("All getters return configured values and MIC roundtrips")
        void testAllMethodsHappyPath() throws Exception {
            // Arrange

        assertTrue(length > 0);
        assertEquals(0, testBlock.wordCount);
        assertEquals(0, testBlock.byteCount);
    }

    @Test
    @DisplayName("Test decode with Snap server workaround")
    void testDecodeWithSnapServerWorkaround() throws SMBProtocolDecodingException {
        testBlock = new TestAndXServerMessageBlock(mockConfig, (byte) 0x25);
        byte[] buffer = new byte[1024];

		name    string
		fv      formValues
		expired bool
		wantErr string
	}

	// Test case just contains fields we override from defaultFormVals.
	testCases := []testCase{
		{
			name:    "happy path no errors",
			fv:      defaultFormVals.Clone(),
			wantErr: "",
		},
		{
			name:    "expired policy document",
			fv:      defaultFormVals.Clone(),
			expired: true,

    }

    static Stream<String> wildcardProvider() {
        return Stream.of(null, "", "*");
    }

    @ParameterizedTest
    @MethodSource("wildcardProvider")
    @DisplayName("open() happy path: yields entries and closes with Smb2CloseRequest on close()")
    void happyPath_enumerates_and_closes(String wildcard) throws Exception {
        // Setup required for this test

             * so let's populate them here
             */

            andxCommand = buffer[bufferIndex];
            andxOffset = readInt2(buffer, bufferIndex + 2);

            if (andxOffset == 0) { /* Snap server workaround */
                andxCommand = (byte) 0xFF;
            }

            /*
             * no point in calling readParameterWordsWireFormat if there are no more

	days := uint64(30)
	daysPtr := &days
	years := uint64(2)
	yearsPtr := &years

	tests := []struct {
		name string
		c    Config
		want string
	}{
		{
			name: "happy case",
			c: Config{
				ObjectLockEnabled: "Enabled",
			},
			want: "Enabled: true",
		},
		{
			name: "with default retention days",
			c: Config{
				ObjectLockEnabled: "Enabled",

    @DisplayName("unwrap returns this for compatible types and throws otherwise")
    void unwrap_success_and_failure() {
        SmbPipeHandleImpl handle = newHandleWithBasicStubs(0, "\\\\pipe\\\\z");

        // Happy path: unwrap to interface and concrete type
        SmbPipeHandle unwrapped1 = handle.unwrap(SmbPipeHandle.class);
        SmbPipeHandleImpl unwrapped2 = handle.unwrap(SmbPipeHandleImpl.class);

        int len = block.decode(buf, 0);
        assertTrue(len > 0);
        assertEquals(4, block.wordCount);
        assertNull(block.andx);
    }

    @Test
    @DisplayName("readAndXWireFormat applies Snap server workaround (offset 0)")
    void testReadAndXWireFormatSnapWorkaround() {
        DummyAndXBlock block = new DummyAndXBlock();
        block.headerStart = 0;

        byte[] buf = new byte[64];

{* ../../docs_src/response_model/tutorial003_02_py39.py hl[8,10:11] *}

This simple case is handled automatically by FastAPI because the return type annotation is the class (or a subclass of) `Response`.

And tools will also be happy because both `RedirectResponse` and `JSONResponse` are subclasses of `Response`, so the type annotation is correct.

### Annotate a Response Subclass { #annotate-a-response-subclass }

                        } catch (CyclicDependencyException e) {
                            // would like to throw this, but we have crappy stuff in the repo

                            fireEvent(
                                    ResolutionListener.OMIT_FOR_CYCLE,
                                    listeners,