}

func trimTrace(f string) string {
	for _, trimString := range trimStrings {
		f = strings.TrimPrefix(filepath.ToSlash(f), filepath.ToSlash(trimString))
	}
	return filepath.FromSlash(f)
}

func getSource(level int) string {
	pc, file, lineNumber, ok := runtime.Caller(level)
	if ok {
		// Clean up the common prefixes

	} else if !os.IsNotExist(err) {
		return dir, err
	}

	// Check if a .ziphash file exists. It should be created before the
	// zip is extracted, but if it was deleted (by another program?), we need
	// to re-calculate it. Note that checkMod will repopulate the ziphash
	// file if it doesn't exist, but if the module is excluded by checks

                }

                @Nonnull
                @Override
                public Optional<Path> getPomFile() {
                    return Optional.ofNullable(res.getPomFile()).map(File::toPath);
                }

                @Nonnull
                @Override
                public Optional<Project> getProject() {
                    return Optional.ofNullable(res.getProject()).map(session::getProject);

                private void createBuildFile(String content) throws IOException {
                    File buildFile = new File(testProjectDir, "build.gradle");
                    Files.write(buildFile.toPath(), content.getBytes());
                }

                @Test
                public void testCustomTask() throws IOException {
                    createBuildFile("plugins { id 'org.example.test' }");

                        throw new IOException("Could not create directory " + currFile);
                    }
                } else {
                    Files.copy(sourceJar.getInputStream(sourceJarEntry), currFile.toPath());
                }
            }
        }
    }

    @Override
    public Statement apply(final Statement statement, FrameworkMethod frameworkMethod, Object target) {

        invalidate(snapshot.absolutePath)
    }

    static RegularFileSnapshot snapshotRegularFile(File regularFile) {
        def attributes = Files.readAttributes(regularFile.toPath(), BasicFileAttributes)
        new RegularFileSnapshot(
            regularFile.absolutePath,
            regularFile.name,
            TestFiles.fileHasher().hash(regularFile),

            ModelBuildingRequest request,
            ModelProblemCollector problems) {
        return new org.apache.maven.model.Model(interpolateModel(
                model.getDelegate(), projectDir != null ? projectDir.toPath() : null, request, problems));
    }

    @Override
    public org.apache.maven.model.Model interpolateModel(
            org.apache.maven.model.Model model,
            Path projectDir,

        validateApi(body, messages -> {});
        return asStream("badword.csv").contentTypeOctetStream().stream(out -> {
            final Path tempFile = ComponentUtil.getSystemHelper().createTempFile("fess-badword-", ".csv").toPath();
            try {
                try (Writer writer = new BufferedWriter(new OutputStreamWriter(Files.newOutputStream(tempFile), getCsvEncoding()))) {
                    badWordService.exportCsv(writer);

            // By moving the inconsistent workspace we also preserve it for later inspection.
            Files.move(immutableLocation.toPath(), failedWorkspaceLocation.toPath(), StandardCopyOption.ATOMIC_MOVE);
        } catch (IOException e) {
            throw new UncheckedIOException(String.format("Could not move inconsistent immutable workspace (%s) to temporary location (%s)",

                    rootLocator.findRoot(pomFile.getParentFile().toPath()));

            DefaultModelBuildingListener listener =
                    new DefaultModelBuildingListener(project, projectBuildingHelper, request);

            ModelBuilderRequest modelBuildingRequest = getModelBuildingRequest()
                    .source(ModelSource.fromPath(pomFile.toPath()))
                    .projectBuild(true)