void setUp() {
        // Directly set the deferred field on the mock
        mockNdrBuffer.deferred = mockDeferredBuffer;

        // Configure mocks for NdrBuffer interactions
        lenient().when(mockDeferredBuffer.derive(anyInt())).thenReturn(mockDeferredBuffer);
        lenient().doNothing().when(mockDeferredBuffer).advance(anyInt());
        // Set up index field for derive operations
        mockDeferredBuffer.index = 0;
    }

)

func TestNSQArgs_Validate(t *testing.T) {
	type fields struct {
		Enable      bool
		NSQDAddress xnet.Host
		Topic       string
		TLS         struct {
			Enable     bool
			SkipVerify bool
		}
	}
	tests := []struct {
		name    string
		fields  fields
		wantErr bool
	}{
		{
			name: "test1_missing_topic",
			fields: fields{
				Enable: true,
				NSQDAddress: xnet.Host{

    }

    @Override
    @ParametricNullness
    // We set the field only once (during construction or deserialization).
    @SuppressWarnings("SynchronizeOnNonFinalField")
    public T get() {
      // Another variant of Double Checked Locking.
      //
      // We use two volatile reads. We could reduce this to one by
      // putting our fields into a holder class, but (at least on x86)

	test1ActiveBuckets2[BucketOptions{Name: "bucket", ReplicationARN: "arn"}] = m1MiBPS

	tests := []struct {
		name   string
		fields fields
		want   *BucketBandwidthReport
		want2  *BucketBandwidthReport
	}{
		{
			name: "ZeroToOne",
			fields: fields{
				activeBuckets: test1ActiveBuckets,
				endTime:       start.Add(1 * time.Second),
				update2:       oneMiB,

        } catch (java.io.IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Test
    @DisplayName("Parses a valid buffer and exposes fields")
    void parseValidBuffer() {
        // Arrange
        String name = "******@****.***";
        byte[] buf = buildBuffer(oidDer(), name.getBytes(StandardCharsets.US_ASCII));

        // Act

			Device:  fields[0],
			Path:    fields[1],
			FSType:  fields[2],
			Options: strings.Split(fields[3], ","),
			Freq:    fields[4],
			Pass:    fields[5],
		})
	}
	return mounts, nil

    @Mock
    private SmbTransport transport;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        // Setup transport fields that are accessed directly
        transport.tconHostName = "testHost";
        // Setup session.transport field (accessed directly in SmbTree)
        session.transport = transport;
        // Setup session to return transport via method call

///

## Multiple models { #multiple-models }

Here's a general idea of how the models could look like with their password fields and the places where they are used:

{* ../../docs_src/extra_models/tutorial001_py310.py hl[7,9,14,20,22,27:28,31:33,38:39] *}

### About `**user_in.model_dump()` { #about-user-in-model-dump }

	elapsed := time.Since(begin)
	sql, rows := fc()
	fields := []slog.Attr{
		slog.String("duration", fmt.Sprintf("%.3fms", float64(elapsed.Nanoseconds())/1e6)),
		slog.String("sql", sql),
	}

	if rows != -1 {
		fields = append(fields, slog.Int64("rows", rows))
	}

	switch {
	case err != nil && (!l.IgnoreRecordNotFoundError || !errors.Is(err, ErrRecordNotFound)):
		fields = append(fields, slog.String("error", err.Error()))

For example, in one of the ways the OAuth2 specification can be used (called "password flow") it is required to send a `username` and `password` as form fields.

The <abbr title="specification">spec</abbr> requires the fields to be exactly named `username` and `password`, and to be sent as form fields, not JSON.