private static class BadLengthFile extends File {

    private final long badLength;

    BadLengthFile(File delegate, long badLength) {
      super(delegate.getPath());
      this.badLength = badLength;
    }

    @Override
    public long length() {
      return badLength;
    }

    private static final long serialVersionUID = 0;
  }

                form.dictId = dictId;
            });
        }).renderWith(data -> {
            kuromojiService.getKuromojiFile(dictId).ifPresent(file -> {
                RenderDataUtil.register(data, "path", file.getPath());
            }).orElse(() -> {
                throwValidationError(messages -> messages.addErrorsFailedToDownloadKuromojiFile(GLOBAL), this::asDictIndexHtml);
            });
        });
    }

    /**

        .build()
    assertThat(headers["Test-Instant"]).isEqualTo("Thu, 01 Jan 1970 00:00:00 GMT")
    assertThat(headers.getInstant("Test-Instant")).isEqualTo(expected)
  }

  @Test fun setDate() {
    val expected = Date(1000)
    val headers =
      Headers
        .Builder()
        .add("testDate", Date(0L))
        .set("testDate", expected)
        .build()

            });
        }).renderWith(data -> {
            stemmerOverrideService.getStemmerOverrideFile(dictId).ifPresent(file -> {
                RenderDataUtil.register(data, "path", file.getPath());
            }).orElse(() -> {
                throwValidationError(messages -> messages.addErrorsFailedToDownloadStemmeroverrideFile(GLOBAL), this::asDictIndexHtml);
            });
        });
    }

                "numOfThread");
        setupEpg(_epgMap, et -> ((FileConfig) et).getPaths(), (et, vl) -> ((FileConfig) et).setPaths(DfTypeUtil.toString(vl)), "paths");
        setupEpg(_epgMap, et -> ((FileConfig) et).getPermissions(), (et, vl) -> ((FileConfig) et).setPermissions((String[]) vl),
                "permissions");

        return MAPPING;
    }

    /**
     * Returns the file path of this character mapping dictionary.
     *
     * @return the file path as a string
     */
    @Override
    public String getPath() {
        return path;
    }

    /**
     * Retrieves a character mapping item by its ID.
     *
     * @param id the unique identifier of the mapping item to retrieve

                form.dictId = dictId;
            });
        }).renderWith(data -> {
            synonymService.getSynonymFile(dictId).ifPresent(file -> {
                RenderDataUtil.register(data, "path", file.getPath());
            }).orElse(() -> {
                throwValidationError(messages -> messages.addErrorsFailedToDownloadSynonymFile(GLOBAL), this::asDictIndexHtml);
            });
        });
    }

    /**

    server.useHttps(sslContext.getSocketFactory(), false);
    server.setDispatcher(this);
    server.start(port);
  }

  @Override public MockResponse dispatch(RecordedRequest request) {
    String path = request.getPath();
    try {
      if (!path.startsWith("/") || path.contains("..")) throw new FileNotFoundException();

      File file = new File(root + path);
      return file.isDirectory()
          ? directoryToResponse(path, file)

     * @return The path of the Zip file specified by the URL.
     */
    public static String toZipFilePath(final URL zipUrl) {
        assertArgumentNotNull("zipUrl", zipUrl);

        final String urlString = zipUrl.getPath();
        final int pos = urlString.lastIndexOf('!');
        final String zipFilePath = urlString.substring(0, pos);
        final File zipFile = new File(URLUtil.decode(zipFilePath, "UTF8"));

            result.setName(DfTypeUtil.toString(source.get("name")));
            result.setNumOfThread(DfTypeUtil.toInteger(source.get("numOfThread")));
            result.setPaths(DfTypeUtil.toString(source.get("paths")));
            result.setPermissions(toStringArray(source.get("permissions")));
            result.setSortOrder(DfTypeUtil.toInteger(source.get("sortOrder")));