Mockito.doAnswer(inv -> {
            Object resp = inv.getArgument(1);
            // Set private fields: status on SmbComTransactionResponse and available on TransPeekNamedPipeResponse
            Field statusField = jcifs.internal.smb1.trans.SmbComTransactionResponse.class.getDeclaredField("status");
            statusField.setAccessible(true);
            statusField.setInt(resp, status);

        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);

	for k, v := range meta {
		azMeta[k] = to.Ptr(v)
	}
	resp, err := az.clnt.UploadStream(ctx, az.Bucket, az.getDest(object), io.LimitReader(r, length), &azblob.UploadStreamOptions{
		Concurrency: 4,
		AccessTier:  az.tier(), // set tier if specified
		Metadata:    azMeta,
	})
	if err != nil {
		return "", azureToObjectError(err, az.Bucket, az.getDest(object))
	}
	vid := ""
	if resp.VersionID != nil {
		vid = *resp.VersionID
	}

                final Smb2IoctlResponse resp = th.send(req, RequestParam.NO_RETRY);
                return ((SrvPipePeekResponse) resp.getOutputData()).getReadDataAvailable();
            }
            final TransPeekNamedPipe req = new TransPeekNamedPipe(th.getConfig(), this.handle.getUncPath(), fd.getFid());
            final TransPeekNamedPipeResponse resp = new TransPeekNamedPipeResponse(th.getConfig());

	json.NewEncoder(w).Encode(map[string]string{
		"reason": fmt.Sprintf("%v", err),
	})
}

type Resp struct {
	User               string                 `json:"user"`
	MaxValiditySeconds int                    `json:"maxValiditySeconds"`
	Claims             map[string]interface{} `json:"claims"`
}

var tokens map[string]Resp = map[string]Resp{
	"aaa": {
		User:               "Alice",
		MaxValiditySeconds: 3600,

        @Test
        @DisplayName("Should construct with config only")
        void testConstructorWithConfig() {
            TestServerMessageBlock2Response resp = new TestServerMessageBlock2Response(mockConfig);
            assertNotNull(resp);
            assertSame(mockConfig, resp.getConfig());
        }

        @Test
        @DisplayName("Should construct with config and command")

	handler := setCrossDomainPolicyMiddleware(router)
	srv := httptest.NewServer(handler)

	resp, err := http.Get(srv.URL + crossDomainXMLEntity)
	if err != nil {
		t.Fatal(err)
	}
	if resp.StatusCode != http.StatusOK {
		t.Fatal("Unexpected http status received", resp.Status)
	}

            if (resp.status == TransPeekNamedPipeResponse.STATUS_DISCONNECTED
                    || resp.status == TransPeekNamedPipeResponse.STATUS_SERVER_END_CLOSED) {
                file.opened = false;
                return 0;
            }
            return resp.available;
        } catch (final SmbException se) {
            throw seToIoe(se);
        }
    }

    /**

        SmbComNTCreateAndXResponse resp = new SmbComNTCreateAndXResponse() {
            @Override
            int readHeaderWireFormat(byte[] buffer, int bufferIndex) {
                return 33;
            }
        };
        // Set command to NT_CREATE_ANDX and mark extended
        resp.command = ServerMessageBlock.SMB_COM_NT_CREATE_ANDX;
        resp.isExtended = true;

        byte[] buf = new byte[256];

        final SmbComTransaction req = new NetShareEnum(th.getConfig());
        final SmbComTransactionResponse resp = new NetShareEnumResponse(th.getConfig());
        th.send(req, resp);
        if (resp.getStatus() != WinError.ERROR_SUCCESS) {
            throw new SmbException(resp.getStatus(), true);
        }

        return resp.getResults();
    }