flist.toArray(new FunctionScoreQueryBuilder.FilterFunctionBuilder[flist.size()]));

        functionScoreQueryBuilder.boostMode(CombineFunction.REPLACE);
        functionScoreQueryBuilder.scoreMode(FunctionScoreQuery.ScoreMode.MULTIPLY);

        return functionScoreQueryBuilder;
    }

    protected SuggestResponse createResponse(final SearchResponse searchResponse) {

                Map.of("_default", List.of("QUERY1")), //
                Set.of("QUERY1"), //
                buildQuery("QUERY1^10"));

    data class ClassLoaderHierarchy(
        val classLoaders: List<ClassLoaderNode>,
        val scopes: List<ScopeNode>
    )

    data class ClassLoaderNode(
        val id: String,
        val label: String,
        val parents: Set<String>,
        val classPath: List<String>
    )

    data class ScopeNode(
        val label: String,
        val localClassLoader: String,
        val exportClassLoader: String,

        private final ModelNodeInternal scopeNode;

        public TryDiscoverSelfDiscoveringInScope(ModelNodeInternal scopeNode) {
            this.scopeNode = scopeNode;
        }

        @Override
        public boolean isAchieved() {
            for (ModelNodeInternal child : scopeNode.getLinks()) {

	if (height)%4 == 0 {
		if shortcut {
			batch[0] = []byte{1}
		} else {
			batch[0] = []byte{0}
		}

		s.storeNode(batch, h, oldRoot)
	}
	return h
}

// storeNode stores a batch and deletes the old node from cache
func (s *smt) storeNode(batch [][]byte, h, oldRoot []byte) {
	if !bytes.Equal(h, oldRoot) {
		var node hash
		copy(node[:], h)
		// record new node

			return nil
		}, retry.Timeout(time.Second*2))
	}

	// send cds before healthcheck, to make wle registered
	coreNode := &core.Node{
		Id:       "sidecar~1.1.1.1~debug~cluster.local",
		Metadata: node.ToStruct(),
	}
	err := downstream.Send(&discovery.DiscoveryRequest{TypeUrl: v3.ClusterType, Node: coreNode})
	if err != nil {
		t.Fatal(err)
	}
	_, err = downstream.Recv()
	if err != nil {
		t.Fatal(err)
	}