boolQueryBuilder.add(termQuery, BooleanClause.Occur.MUST);
        BooleanQuery booleanQuery = boolQueryBuilder.build();

        QueryContext context = new QueryContext("test", false);
        QueryBuilder result = booleanQueryCommand.execute(context, booleanQuery, 1.0f);

        assertNotNull(result);
        assertTrue(result instanceof BoolQueryBuilder);

        return category;
    }

    /**
     * Gets the error context
     *
     * @return the context map
     */
    public Map<String, Object> getContext() {
        return new HashMap<>(context);
    }

    /**
     * Gets a specific context value
     *
     * @param key the context key
     * @return the context value or null
     */
    public Object getContextValue(String key) {

            int bytesRead = context.decode(buffer, 0, 8);

            assertEquals(8, bytesRead);
            assertNotNull(context.getHashAlgos());
            assertEquals(2, context.getHashAlgos().length);
            assertEquals(0x01, context.getHashAlgos()[0]);
            assertEquals(0x02, context.getHashAlgos()[1]);
            assertNotNull(context.getSalt());
            assertEquals(0, context.getSalt().length);
        }

	return etcdErrToErr(err, client.Endpoints())
}

func deleteKeyEtcd(ctx context.Context, client *etcd.Client, key string) error {
	timeoutCtx, cancel := context.WithTimeout(ctx, defaultContextTimeout)
	defer cancel()

	_, err := client.Delete(timeoutCtx, key)
	etcdLogIf(ctx, err)
	return etcdErrToErr(err, client.Endpoints())
}

func readKeyEtcd(ctx context.Context, client *etcd.Client, key string) ([]byte, error) {

@Test
public void testDirectoryChangeNotification() throws Exception {
    CIFSContext context = getTestContext();
    context.getConfig().setProperty("jcifs.smb.client.directoryNotificationsEnabled", "true");
    
    SmbFile dir = new SmbFile("smb://server/share/testdir/", context);
    SmbFile testFile = new SmbFile("smb://server/share/testdir/newfile.txt", context);
    
    // Get initial listing (establishes cache)

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

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

        void testDefaultConstructor() {
            // Act
            context = new EncryptionNegotiateContext();

            // Assert
            assertEquals(EncryptionNegotiateContext.NEGO_CTX_ENC_TYPE, context.getContextType());
            assertNull(context.getCiphers());
        }

        @Test
        @DisplayName("Should encode context correctly")

	return err
}

func readServerConfigHistory(ctx context.Context, objAPI ObjectLayer, uuidKV string) ([]byte, error) {
	historyFile := pathJoin(minioConfigHistoryPrefix, uuidKV+kvPrefix)
	data, err := readConfig(ctx, objAPI, historyFile)
	if err != nil {
		return nil, err
	}

	return decryptData(data, historyFile)
}

func saveServerConfigHistory(ctx context.Context, objAPI ObjectLayer, kv []byte) error {

	if t, ok := config.Tiers[tierName]; ok {
		return t.Type, true
	}
	return madmin.Unsupported, false
}

// Add adds tier to config if it passes all validations.
func (config *TierConfigMgr) Add(ctx context.Context, tier madmin.TierConfig, ignoreInUse bool) error {
	config.Lock()
	defer config.Unlock()

	// check if tier name is in all caps
	tierName := tier.Name
	if tierName != strings.ToUpper(tierName) {