private byte[] data;

    private String encoding;

    private Set<RequestData> childUrlSet = new LinkedHashSet<>();

    public byte[] getData() {
        return data;
    }

    public void setData(final byte[] data) {
        this.data = data;
    }

    public void addUrl(final RequestData url) {
        childUrlSet.add(url);
    }

    public void addAllUrl(final Collection<RequestData> c) {

        return new CompositeOperation<TaskExecution>(taskExecutions);
    }

    /**
     * Get the String project path.
     */
    public String getPath() {
        return projectPath;
    }

    /**
     * Returns the configuration time of this project.
     */
    public ContinuousOperation getConfigurationOperation() {
        return configurationOperation;

        File f = new File(getBasedir(), path);

        f.createNewFile();

        return artifactRepositoryFactory.createArtifactRepository(
                "test", "file://" + f.getPath(), repoLayout, null, null);
    }

    protected String getRepositoryLayout() {
        return "default";
    }

    protected ArtifactRepository localRepository() throws Exception {

        final DictionaryManager dictionaryManager = new DictionaryManager();
        final SynonymCreator synonymCreator = new SynonymCreator();
        final SynonymFile synonymFile = (SynonymFile) synonymCreator.create(file1.getPath(), new Date());
        dictionaryManager.store(synonymFile, file1);
        final DictionaryFile<? extends DictionaryItem>[] synonymFiles = dictionaryManager.getDictionaryFiles();
        assertEquals(1, synonymFiles.length);

			vol, ok := pubs[csiMounter.volumeID]
			if !ok {
				t.Error("csi server may not have received NodePublishVolume call")
			}
			if vol.Path != csiMounter.GetPath() {
				t.Errorf("csi server expected path %s, got %s", csiMounter.GetPath(), vol.Path)
			}
			if !reflect.DeepEqual(vol.MountFlags, expectedMountOptions) {
				t.Errorf("csi server expected mount options %v, got %v", expectedMountOptions, vol.MountFlags)

        throw new UnsupportedOperationException();
    }

    @Override
    public String getName() {
        return file.getName();
    }

    @Override
    public String getPath() {
        return getRelativePath().getPathString();
    }

    @Override
    public RelativePath getRelativePath() {
        return relativePath;
    }

    @Override
    @Deprecated

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

                        public String getSettingsFile() {
                            File settingsFile = settingsLocation.getSettingsFile();
                            return settingsFile != null ? settingsFile.getPath() : null;
                        }

                    });
            }
        });
    }

        policy.setUpdatePolicy("always");

        Repository repository = new Repository();
        repository.setId(RepositorySystem.DEFAULT_REMOTE_REPO_ID);
        repository.setUrl("file://" + repoDir.toURI().getPath());
        repository.setReleases(policy);
        repository.setSnapshots(policy);

        return Arrays.asList(repositorySystem.buildArtifactRepository(repository));
    }

                    e);
            throw problems.newModelBuilderException();
        }

        if (modelSource.getPath() != null) {
            model = model.withPomFile(modelSource.getPath());
        }

        problems.setSource(model);
        modelValidator.validateFileModel(model, request, problems);
        if (hasFatalErrors(problems)) {