assertNull(delegatingConfig.getRandom(), "Should return null when delegate returns null");
        assertNull(delegatingConfig.getLocalAddr(), "Should return null when delegate returns null");
        assertNull(delegatingConfig.getNetbiosHostname(), "Should return null when delegate returns null");
        assertNull(delegatingConfig.getResolveOrder(), "Should return null when delegate returns null");

  fun metadata(): ByteString = metadata

  /**
   * Returns a new source that returns the same bytes as upstream. Returns null if this relay has
   * been closed and no further sources are possible. In that case callers should retry after
   * building a new relay with [.read].
   */
  fun newSource(): Source? {
    synchronized(this@Relay) {
      if (file == null) return null
      sourceCount++
    }

                return FormatType.SCROLL;
            }
            return FormatType.SEARCH;
        }
        if ("labels".equals(type)) {
            return FormatType.LABEL;
        }
        if ("popular-words".equals(type)) {
            return FormatType.POPULARWORD;
        }
        if ("favorites".equals(type)) {
            return FormatType.FAVORITES;
        }

            return transformCallCount.get();
        }

        public int getGetDataCallCount() {
            return getDataCallCount.get();
        }

        public ResponseData getLastResponseData() {
            return lastResponseData;
        }

        public AccessResultData<?> getLastAccessResultData() {
            return lastAccessResultData;
        }

      return standardContainsAll(collection);
    }

    @Override
    public boolean remove(Object object) {
      return standardRemove(object);
    }

    @Override
    public boolean removeAll(Collection<?> collection) {
      return standardRemoveAll(collection);
    }

    @Override
    public boolean retainAll(Collection<?> collection) {
      return standardRetainAll(collection);
    }

    }

    /**
     * Sets the indices timeout.
     * @param timeout The indices timeout.
     * @return This builder instance.
     */
    public SuggestSettingsBuilder indicesTimeout(final String timeout) {
        timeoutSettings.indicesTimeout = timeout;
        return this;
    }

    /**
     * Sets the cluster timeout.
     * @param timeout The cluster timeout.

				lookupConfigs(srvCfg, objAPI)
				return srvCfg, nil
			}
			return nil, err
		}

		data, err = decryptData(data, configFile)
		if err != nil {
			lookupConfigs(srvCfg, objAPI)
			return nil, err
		}
	}

	json := jsoniter.ConfigCompatibleWithStandardLibrary
	if err := json.Unmarshal(data, &srvCfg); err != nil {
		return nil, err
	}

	// Add any missing entries

    public boolean hasAggregations() {
        return aggregationAggregationBuilderList != null && !aggregationAggregationBuilderList.isEmpty();
    }

    public List<AbstractAggregationBuilder<?>> getAggregationBuilderList() {
        return aggregationAggregationBuilderList != null ? aggregationAggregationBuilderList : Collections.emptyList();
    }

        if (!filePath.startsWith("storage:")) {
            filePath = "storage://" + filePath;
        }

        return filePath;
    }

    /**
     * Returns the character set used for content encoding.
     * @return the charset
     */
    public String getCharset() {
        return charset;
    }

    /**
     * Sets the character set used for content encoding.

			t.Errorf("Leaked goroutine: %v", g)
		}
		return
	}
}

// DetectTestLeak -  snapshots the currently running goroutines and returns a
// function to be run at the end of tests to see whether any
// goroutines leaked.
// Usage: `defer DetectTestLeak(t)()` in beginning line of benchmarks or unit tests.
func DetectTestLeak(t TestErrHandler) func() {
	initialStackSnapShot := NewLeakDetect()
	return func() {
		initialStackSnapShot.DetectLeak(t)