// Multiple threads accessing context simultaneously
                    for (int j = 0; j < 50; j++) {
                        context.getConfig();
                        context.getBufferCache();
                        context.getDfs();
                        context.getNameServiceClient();
                        context.getSIDResolver();
                        context.getTransportPool();

     *
     * @param context the query context
     * @param termQuery the term query to convert
     * @param boost the boost value to apply
     * @return the converted QueryBuilder
     */
    protected QueryBuilder convertTermQuery(final QueryContext context, final TermQuery termQuery, final float boost) {
        final String field = getSearchField(context.getDefaultField(), termQuery.getTerm().field());

            when(transportPool.getChallenge(context, address)).thenReturn(challenge);
            doNothing().when(transportPool).logon(context, address);

            // When
            byte[] retrievedChallenge = transportPool.getChallenge(context, address);
            transportPool.logon(context, address);

            // Then
            assertNotNull(retrievedChallenge);

        assertActivation(false, newExistsProfile("someFile.txt"), context);
        assertActivation(false, newExistsProfile("${project.basedir}/someFile.txt"), context);

        assertActivation(false, newMissingProfile(null), context);
        assertActivation(true, newMissingProfile("someFile.txt"), context);
        assertActivation(true, newMissingProfile("${project.basedir}/someFile.txt"), context);
    }

        RequestTrace parentTrace = new RequestTrace("parent-context", null, "parent-data");
        RequestTrace childTrace = new RequestTrace("child-context", parentTrace, "child-data");

        assertEquals("parent-context", parentTrace.context());
        assertNull(parentTrace.parent());
        assertEquals("parent-data", parentTrace.data());

        assertEquals("child-context", childTrace.context());

        SecDispatcher.ValidationResponse response = secDispatcher.validateConfiguration();
        if (!response.isValid() || context.options().verbose().orElse(false)) {
            dumpResponse(context, "", response);
        }
        return response.isValid();
    }

    protected void dumpResponse(EncryptContext context, String indent, SecDispatcher.ValidationResponse response) {

func (c *lockRESTClient) RUnlock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCRUnlock, &args)
}

// Refresh calls Refresh REST API.
func (c *lockRESTClient) Refresh(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCRefresh, &args)
}

// Unlock calls write unlock RPC.

func (client *peerRESTClient) GetLocks(ctx context.Context) (lockMap map[string][]lockRequesterInfo, err error) {
	resp, err := getLocksRPC.Call(ctx, client.gridConn(), grid.NewMSS())
	if err != nil || resp == nil {
		return nil, err
	}
	return *resp, nil
}

// LocalStorageInfo - fetch server information for a remote node.
func (client *peerRESTClient) LocalStorageInfo(ctx context.Context, metrics bool) (info StorageInfo, err error) {

        assertTrue(context.supportsAlgorithm(CompressionNegotiateContext.COMPRESSION_LZ77));
        assertTrue(context.supportsAlgorithm(CompressionNegotiateContext.COMPRESSION_LZ77_HUFFMAN));
        assertTrue(context.supportsAlgorithm(CompressionNegotiateContext.COMPRESSION_LZNT1));
        assertFalse(context.supportsAlgorithm(CompressionNegotiateContext.COMPRESSION_PATTERN_V1));
    }

    @Test
    @DisplayName("Test context encoding")

    }

    /**
     * Sets the context handle for unregistration.
     *
     * @param contextHandle the context handle from registration
     */
    public void setContextHandle(byte[] contextHandle) {
        this.contextHandle = contextHandle != null ? contextHandle.clone() : null;
    }

    /**
     * Gets the context handle.
     *
     * @return the context handle
     */