func newWholeBitrotWriter(disk StorageAPI, volume, filePath string, algo BitrotAlgorithm, shardSize int64) io.WriteCloser {
	return &wholeBitrotWriter{disk, volume, filePath, shardSize, algo.New()}
}

// Implementation to verify bitrot for the whole file.
type wholeBitrotReader struct {
	disk       StorageAPI
	volume     string
	filePath   string
	verifier   *BitrotVerifier // Holds the bit-rot info

pkg net, type Resolver struct, Dial func(context.Context, string, string) (Conn, error)
pkg net, type Resolver struct, StrictErrors bool
pkg net/http, func ServeTLS(net.Listener, Handler, string, string) error
pkg net/http, method (*Server) RegisterOnShutdown(func())
pkg net/http, method (*Server) ServeTLS(net.Listener, string, string) error
pkg net/http/fcgi, func ProcessEnv(*http.Request) map[string]string

    @PluginFactory
    public static ErrorToWarnRewritePolicy createPolicy(@PluginAttribute("loggers") final String loggerNamePrefix) {
        final String[] loggerNames = loggerNamePrefix != null
                ? Arrays.stream(loggerNamePrefix.split(",")).map(String::trim).filter(s -> s.length() > 0).toArray(n -> new String[n])
                : new String[0];
        return new ErrorToWarnRewritePolicy(loggerNames);
    }

        @DisplayName("Should get and set key")
        void testGetAndSetKey() {
            String key = "cache-key-123";

            // Test with mock
            when(mockReferralData.getKey()).thenReturn(key);
            doNothing().when(mockReferralData).setKey(key);

            mockReferralData.setKey(key);
            String retrievedKey = mockReferralData.getKey();

            assertEquals(key, retrievedKey);

    }

    @Override
    public NbtAddress getNbtByName(final String host) throws UnknownHostException {
        return getNbtByName(host, 0x00, null);
    }

    @Override
    public NbtAddress getNbtByName(final String host, final int type, final String scope) throws UnknownHostException {
        return getNbtByName(host, type, scope, null);
    }

    @Override

        return getStopwordsFile(dictId).map(file -> file.get(id).get());
    }

    /**
     * Stores a stopword item in the specified dictionary.
     *
     * @param dictId        The ID of the dictionary.
     * @param stopwordsItem The stopword item to store.
     */
    public void store(final String dictId, final StopwordsItem stopwordsItem) {

    public OptionalEntity<SynonymItem> getSynonymItem(final String dictId, final long id) {
        return getSynonymFile(dictId).map(file -> file.get(id).get());
    }

    /**
     * Stores a synonym item in the specified dictionary.
     *
     * @param dictId      The ID of the dictionary.
     * @param synonymItem The synonym item to store.
     */
    public void store(final String dictId, final SynonymItem synonymItem) {

     */
    public static void load(final Properties props, final String path) {
        assertArgumentNotNull("props", props);
        assertArgumentNotEmpty("path", path);

        load(props, ResourceUtil.getResource(path));
    }

    /**
     * Wraps exception handling for {@link Properties#store(OutputStream, String)}.
     *
     * <p>
     * The output stream is not closed.
     * </p>

    }

    /** Case 1: Normal merge (no duplicates) */
    public void test_mergeResponseData_noOverwrite() {
        Map<String, Object> dataMap = new HashMap<>();
        dataMap.put("a", "A0");
        Map<String, Object> responseDataMap = new HashMap<>();
        responseDataMap.put("b", "B1");

        indexUpdateCallback.mergeResponseData(dataMap, responseDataMap);

    }

  fun addHeader(header: String) =
    apply {
      headersBuilder.add(header)
    }

  fun addHeader(
    name: String,
    value: Any,
  ) = apply {
    headersBuilder.add(name, value.toString())
  }

  fun addHeaderLenient(
    name: String,
    value: Any,
  ) = apply {
    addHeaderLenient(headersBuilder, name, value.toString())
  }

  fun setHeader(