_, err = dexClient.Do(req)
	if err != nil {
		return "", fmt.Errorf("post form err: %v", err)
	}
	// fmt.Printf("resp: %#v %#v\n", resp.StatusCode, resp.Header)
	// bodyBuf, err := io.ReadAll(resp.Body)
	// if err != nil {
	// 	return "", fmt.Errorf("Error reading body: %v", err)
	// }
	// fmt.Printf("resp body: %s\n", string(bodyBuf))
	// fmt.Printf("lastReq: %#v\n", lastReq.URL.String())

            Trans2FindFirst2Response resp = inv.getArgument(1);
            // First response content
            FE[] res = java.util.Arrays.stream(batches.get(0)).map(FE::new).toArray(FE[]::new);
            setField(resp, jcifs.internal.smb1.trans.SmbComTransactionResponse.class, "results", res);
            setField(resp, Trans2FindFirst2Response.class, "sid", 42);
            setField(resp, Trans2FindFirst2Response.class, "resumeKey", 100);

func populateProviderInfoFromClaims(claims map[string]any, provider string, resp *madmin.InfoAccessKeyResp) {
	resp.UserProvider = provider
	switch provider {
	case madmin.LDAPProvider:
		resp.LDAPSpecificInfo = getLDAPInfoFromClaims(claims)
	case madmin.OpenIDProvider:
		resp.OpenIDSpecificInfo = getOpenIDInfoFromClaims(claims)
	}
}

	}

	rec := httptest.NewRecorder()
	adminTestBed.router.ServeHTTP(rec, req)

	resp, _ := io.ReadAll(rec.Body)
	if rec.Code != http.StatusOK {
		t.Errorf("Expected to receive %d status code but received %d. Body (%s)",
			http.StatusOK, rec.Code, string(resp))
	}

	result := &serviceResult{}
	if err := json.Unmarshal(resp, result); err != nil {
		t.Error(err)
	}
	_ = result

        byte command = (byte) 0x25;
        byte subcommand = (byte) 0x01;
        TestSmbComTransactionResponse resp = new TestSmbComTransactionResponse(mockConfig, command, subcommand);
        assertNotNull(resp);
        assertEquals(command, resp.getCommand());
        assertEquals(subcommand, resp.getSubCommand());
    }

    @Test
    @DisplayName("Test dataCount getter and setter")
    void testDataCountGetterSetter() {

        CommonServerMessageBlockResponse resp = mock(CommonServerMessageBlockResponse.class);

        // Configure the tree to throw transport error on first call, succeed on second
        when(tree.send(eq(req), eq(resp), anySet()))
                .thenThrow(new SmbException("transport error", new jcifs.util.transport.TransportException()))
                .thenReturn(resp);

        setTree(c, tree);

	}

	res := madmin.HealResultItem{
		Type:     madmin.HealItemBucket,
		Bucket:   bucket,
		SetCount: -1, // explicitly set an invalid value -1, for bucket heal scenario
	}

	for i, err := range errs {
		if err == nil {
			res.Before.Drives = append(res.Before.Drives, healBucketResults[i].Before.Drives...)
			res.After.Drives = append(res.After.Drives, healBucketResults[i].After.Drives...)

        assertEquals(1111L, resp.getCreateTime()); // SmbBasicFileInfo mapping
        assertEquals(2222L, resp.getLastAccessTime());
        assertEquals(3333L, resp.getLastWriteTime());
        assertEquals(4444L, resp.getChangeTime());
        assertEquals(123456789L, resp.getAllocationSize());
        assertEquals(987654321L, resp.getEndOfFile());
        assertEquals(987654321L, resp.getSize()); // SmbBasicFileInfo mapping

                e = i - 4;
                break;
            }
        }

        final StackTraceElement[] res = new StackTraceElement[e - s];
        System.arraycopy(stackTrace, s, res, 0, e - s);
        return res;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.lang.Object#finalize()
     */
    @Override

					l := newLocker()
					for range locks {
						var tmp [16]byte
						rng.Read(tmp[:])
						res := []string{hex.EncodeToString(tmp[:])}

						for range readers {
							rng.Read(tmp[:])
							ok, err := l.RLock(t.Context(), dsync.LockArgs{
								UID:       uuid.NewString(),
								Resources: res,
								Source:    hex.EncodeToString(tmp[:8]),
								Owner:     hex.EncodeToString(tmp[8:]),