private final Map<String, String> userProperties;
    private final Map<String, String> systemProperties;
    private final Instant startTime = Instant.now();

    ProtoSession(RepositorySystemSession session, RepositorySystem repositorySystem, Lookup lookup) {
        this(session, repositorySystem, Collections.emptyList(), null, lookup, new Context(Map.of(), Map.of()));
    }

    protected ProtoSession(

      ImmutableList<Cell<R, C, V>> cellList,
      ImmutableSet<R> rowSpace,
      ImmutableSet<C> columnSpace) {
    Map<R, Integer> rowIndex = Maps.indexMap(rowSpace);
    Map<R, Map<C, V>> rows = Maps.newLinkedHashMap();
    for (R row : rowSpace) {
      rows.put(row, new LinkedHashMap<C, V>());
    }
    Map<C, Map<R, V>> columns = Maps.newLinkedHashMap();
    for (C col : columnSpace) {
      columns.put(col, new LinkedHashMap<R, V>());

		rs.Err = err
	}
}

// GetAll returns replication metrics for all buckets at once.
func (r *ReplicationStats) GetAll() map[string]BucketReplicationStats {
	if r == nil {
		return map[string]BucketReplicationStats{}
	}

	r.RLock()

	bucketReplicationStats := make(map[string]BucketReplicationStats, len(r.Cache))
	for k, v := range r.Cache {
		bucketReplicationStats[k] = v.Clone()
	}
	r.RUnlock()

type allHealState struct {
	sync.RWMutex

	// map of heal path to heal sequence
	healSeqMap map[string]*healSequence // Indexed by endpoint
	// keep track of the healing status of disks in the memory
	//   false: the disk needs to be healed but no healing routine is started
	//    true: the disk is currently healing
	healLocalDisks map[Endpoint]bool
	healStatus     map[string]healingTracker // Indexed by disk ID
}

                .proxies(request.getProxies().stream().map(Proxy::getDelegate).collect(Collectors.toList()))
                .servers(request.getServers().stream().map(Server::getDelegate).collect(Collectors.toList()))
                .mirrors(request.getMirrors().stream().map(Mirror::getDelegate).collect(Collectors.toList()))
                .profiles(request.getProfiles().stream()
                        .map(Profile::getDelegate)

    }

    public void putAll(final Map<String, String> map) {
        params.putAll(map);
    }

    public boolean containsKey(final String key) {
        return params.containsKey(key);
    }

    public Map<String, Object> asMap() {
        return new ParamMap<>(new HashMap<>(getDataMap(params)));
    }

    protected static Map<String, Object> getDataMap(final Map<String, Object> params) {

     * {@link org.codelibs.core.collection.CollectionsUtil#isEmpty(java.util.Map)}
     * .
     */
    @Test
    public void testIsEmptyMapOfQQ() {
        HashMap<String, String> map = null;
        assertThat(CollectionsUtil.isEmpty(map), is(true));
        map = new HashMap<String, String>();
        assertThat(CollectionsUtil.isEmpty(map), is(true));
    }

    /**
     * Test method for

    public void storeQueryId(final String queryId, final List<Map<String, Object>> documentItems) {
        LaRequestUtil.getOptionalRequest().map(req -> req.getSession(false)).ifPresent(session -> {
            final FessConfig fessConfig = ComponentUtil.getFessConfig();

            final List<String> docIdList = new ArrayList<>();
            for (final Map<String, Object> map : documentItems) {

        }
        RenderDataUtil.register(data, "webConfigItems", itemList);
    }

    protected Map<String, String> createItem(final String label, final String value) {
        final Map<String, String> map = new HashMap<>(2);
        map.put(Constants.ITEM_LABEL, label);
        map.put(Constants.ITEM_VALUE, value);
        return map;
    }

    // ===================================================================================

     */
    @Override
    public void setCacheMap ( Map<String, DfsReferralDataInternal> map ) {
        this.map = map;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.dfs.DfsReferralDataInternal#replaceCache()
     */
    @Override
    public void replaceCache () {
        if ( this.map != null && this.key != null ) {