import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
@Test
public void menuItemsDisabledWhenNotLockedWithCustomStateHelper() {
    builder.addSave(new MockSaveButton());
    builder.addRename(mock(Command.class));
    builder.addDelete(mock(Command.class));
    builder.setLockSyncMenuStateHelper((final Path file,
                                        final boolean isLocked,
                                        final boolean isLockedByCurrentUser) -> Operation.DISABLE);

    final Menus menus = builder.build();

    //Not locked, MenuItems should normally be enabled however our custom helper forces disable
    final UpdatedLockStatusEvent event = new UpdatedLockStatusEvent(mock(Path.class),
                                                                    false,
                                                                    false);

    builder.onEditorLockInfo(event);

    assertMenuItemEnabled(menus.getItems().get(0),
                          false);
    assertMenuItemEnabled(menus.getItems().get(1),
                          false);
    assertMenuItemEnabled(menus.getItems().get(2),
                          false);
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
@Override
public Path save(final Path resource,
                 final SolverConfigModel config,
                 final Metadata metadata,
                 final String comment) {
    try {
        Metadata currentMetadata = metadataService.getMetadata(resource);
        ioService.write(Paths.convert(resource),
                        configPersistence.toXML(config),
                        metadataService.setUpAttributes(resource,
                                                        metadata),
                        commentedOptionFactory.makeCommentedOption(comment));

        fireMetadataSocialEvents(resource,
                                 currentMetadata,
                                 metadata);

        return resource;
    } catch (Exception e) {
        throw ExceptionUtilities.handleException(e);
    }
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
@Test
public void copyRestrictedPathIfExistsTest() {
    final List<Path> paths = new ArrayList<Path>();
    paths.add(createFile("file0.txt"));
    paths.add(createFile("file1.txt"));
    paths.add(createFile("file2.txt"));

    givenThatPathIsUnrestricted(paths.get(0));
    givenThatPathIsRestricted(paths.get(1));
    givenThatPathIsUnrestricted(paths.get(2));

    try {
        whenPathsAreCopiedIfExists(paths);
    } catch (RuntimeException e) {
        thenPathWasNotCopiedIfExists(paths.get(1),
                                     e);
    }

    thenPathWasCopiedIfExists(paths.get(0));
    thenPathWasNotCopiedIfExists(paths.get(1));

    // This will not be copied because the process stops when some exception is raised.
    thenPathWasNotCopiedIfExists(paths.get(2));
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
@Override
public Project resolveParentProject(final Path resource) {
    try {
        //Null resource paths cannot resolve to a Project
        if (resource == null) {
            return null;
        }
        //Check if resource is the project root
        org.uberfire.java.nio.file.Path path = Paths.convert(resource).normalize();

        if (hasPom(path)) {
            final Path projectRootPath = Paths.convert(path);
            return new Project(projectRootPath,
                               Paths.convert(path.resolve(POM_PATH)),
                               projectRootPath.getFileName());
        } else {
            return null;
        }
    } catch (Exception e) {
        throw ExceptionUtilities.handleException(e);
    }
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
@Test
public void testResourceBatchChangesEventDeleteNonPomFile() {
    final Path path = mock(Path.class);
    final org.uberfire.java.nio.file.Path nioPath = mock(org.uberfire.java.nio.file.Path.class);
    when(path.getFileName()).thenReturn("cheese.drl");
    when(path.toURI()).thenReturn("file://project1/cheese.drl");
    when(ioService.get(any(URI.class))).thenReturn(nioPath);

    final Map<Path, Collection<ResourceChange>> batch = new HashMap<Path, Collection<ResourceChange>>() {{
        put(path,
            new ArrayList<ResourceChange>() {{
                add(new ResourceDeleted(""));
            }});
    }};

    bridge.onBatchResourceChanges(new ResourceBatchChangesEvent(batch,
                                                                "message",
                                                                sessionInfo));

    verify(deleteProjectEvent,
           times(0)).fire(any(DeleteProjectEvent.class));
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
public static Path convert(final org.uberfire.java.nio.file.Path path) {
    if (path == null) {
        return null;
    }

    if (path.getFileName() == null) {
        return newPath("/",
                       path.toUri().toString(),
                       new HashMap<String, Object>(1) {{
                           put(PathFactory.VERSION_PROPERTY,
                               path.getFileSystem().supportedFileAttributeViews().contains("version"));
                       }});
    }

    return newPath(path.getFileName().toString(),
                   path.toUri().toString(),
                   new HashMap<String, Object>(1) {{
                       put(PathFactory.VERSION_PROPERTY,
                           path.getFileSystem().supportedFileAttributeViews().contains("version"));
                   }});
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
@Test
public void testVersionChangeForSomeOtherFile() throws Exception {
    VersionRecord versionRecord1 = getVersionRecord("111");
    records.add(versionRecord1);
    VersionRecord versionRecord2 = getVersionRecord("222");
    records.add(versionRecord2);

    screen.init(path222);

    screen.refresh("222");

    verify(view).setup(eq("222"),
                       any(AsyncDataProvider.class));

    Path pathToFile = mock(Path.class);
    when(pathToFile.toURI()).thenReturn("hehe//another.file");
    screen.onVersionChange(new VersionSelectedEvent(pathToFile,
                                                    getVersionRecord("111")));

    verify(view).setup(eq("222"),
                       any(AsyncDataProvider.class));
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
public static String removeExtension(final Path path,
                                     final ResourceTypeDefinition type) {
    if (path == null) {
        return null;
    }
    final String fileName = path.getFileName();
    if (type == null) {
        return fileName;
    }
    final int index = indexOfExtension(type,
                                       fileName);
    if (index == -1) {
        return fileName;
    } else {
        return fileName.substring(0,
                                  index);
    }
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
@Override
public Collection<ValidationMessage> validate(final Path path) {
    if (path != null) {
        String dataObjectSource = ioService.readAllString(Paths.convert(path));
        GenerationResult generationResult = dataModelerService.loadDataObject(path,
                                                                              dataObjectSource,
                                                                              path);

        if (generationResult.hasErrors()) {
            return Collections.emptyList();
        } else {
            DataObject dataObject = generationResult.getDataObject();
            if (dataObject.getAnnotation(PLANNING_SOLUTION_ANNOTATION) != null) {
                return Arrays.asList(new PlanningSolutionToBeDuplicatedMessage(Level.ERROR));
            }
        }
    }
    return Collections.emptyList();
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
@Before
public void setUp() {
    initProjectResourcePathResolvers(PROJECT_RESOURCE_PATH_RESOLVERS_SIZE);
    when(resourcePathResolversInstance.iterator()).thenReturn(projectResourcePathResolvers.iterator());

    resourceResolver = spy(new ResourceResolver(ioService,
                                                pomService,
                                                configurationService,
                                                commentedOptionFactory,
                                                backward,
                                                resourcePathResolversInstance) {
        @Override
        public Project resolveProject(Path resource) {
            return null;
        }

        @Override
        public Project simpleProjectInstance(org.uberfire.java.nio.file.Path nioProjectRootPath) {
            return null;
        }
    });
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
@Test
public void projectDoesNotExist() throws Exception {
    when(repository.getDefaultBranch()).thenReturn("master");

    Path path = mock(Path.class);
    when(path.getFileName()).thenReturn("");
    when(path.toURI()).thenReturn("file://project/");

    when(repository.getBranchRoot("master")).thenReturn(path);

    final JobResult jobResult = helper.testProject(null,
                                                   "repositoryAlias",
                                                   "project");
    assertEquals(JobStatus.RESOURCE_NOT_EXIST,
                 jobResult.getStatus());
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
@Override
public LockInfo retrieveLockInfo(Path path)
        throws IllegalArgumentException, IOException {

    final Path vfsLock = PathFactory.newLock(path);
    final org.uberfire.java.nio.file.Path realLock = Paths.convert(vfsLock);

    if (ioService.exists(realLock)) {
        try {
            final String lockedBy = ioService.readAllString(realLock);
            return new LockInfo(true,
                                lockedBy,
                                path,
                                vfsLock);
        } catch (NoSuchFileException nsfe) {
            // We want to avoid starting a batch (to ensure cluster-wide consistent reads) here since 
            // this method is invoked very frequently. Therefore it's possible that the lock file
            // was deleted after the check to exists but before readAllString was invoked. There's
            // no need for special exception handling as it simply means that file is no longer locked.
        }
    }
    return new LockInfo(false,
                        null,
                        path,
                        vfsLock);
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
public static PluginSimpleContent getScreenWithMainAndTitle() {
    Map<CodeType, String> codeMap = new HashMap<CodeType, String>();
    codeMap.put(CodeType.MAIN,
                "alert('main');");
    codeMap.put(CodeType.TITLE,
                "My Title");
    Path path = null;
    Set<Framework> frameworks = new HashSet<Framework>();
    PluginSimpleContent plugin = new PluginSimpleContent("ScreenWithTitle",
                                                         PluginType.SCREEN,
                                                         path,
                                                         "",
                                                         "",
                                                         codeMap,
                                                         frameworks,
                                                         Language.JAVASCRIPT);
    return plugin;
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
private void loadContent(final NavigatorItem parent,
                         final Path path) {
    if (path != null) {
        navigatorService.call(new RemoteCallback<NavigatorContent>() {
            @Override
            public void callback(final NavigatorContent response) {
                for (final DataContent dataContent : response.getContent()) {
                    if (dataContent.isDirectory()) {
                        if (options.showDirectories()) {
                            parent.addDirectory(dataContent.getPath());
                        }
                    } else {
                        if (options.showFiles()) {
                            if (!options.showHiddenFiles() && !hiddenTypeDef.accept(dataContent.getPath())) {
                                parent.addFile(dataContent.getPath());
                            } else if (options.showHiddenFiles()) {
                                parent.addFile(dataContent.getPath());
                            }
                        }
                    }
                }
            }
        }).listContent(path);
    }
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
@Override
public boolean hasRestriction(final Path path) {
    for (RenameRestrictor renameRestrictor : getRenameRestrictors()) {
        final PathOperationRestriction renameRestriction = renameRestrictor.hasRestriction(path);
        if (renameRestriction != null) {
            return true;
        }
    }

    return false;
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
public static LockResult acquired(final Path path,
                                  final String lockedBy) {

    return new LockResult(true,
                          new LockInfo(true,
                                       lockedBy,
                                       path));
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
@Test
public void buildTargetPathForResourceTypeFileInAnotherDirectoryTest() {
    String extension = ".resource.xml.txt";

    Path originalPath = createFile("parent/resource-file" + extension);
    Path targetParentDirectory = createFolder("new-parent");
    String targetFileName = "new-resource-file";

    Path targetPath = pathNamingService.buildTargetPath(originalPath,
                                                        targetParentDirectory,
                                                        targetFileName);

    assertEquals(targetParentDirectory.toURI() + "/" + targetFileName + extension,
                 targetPath.toURI());
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
private void setBranches(final FileSystem fileSystem) {
    final Map<String, Path> branches = getBranches(fileSystem);

    repo.setBranches(branches);

    repo.setRoot(getDefaultRoot(fileSystem,
                                branches));
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
@Test
public void forceReleaseLockSucceedsIfLockNotOwned() {
    when(ioService.exists(any(org.uberfire.java.nio.file.Path.class))).thenReturn(true);
    when(ioService.readAllString(any(org.uberfire.java.nio.file.Path.class))).thenReturn("some-other-user");

    final LockResult result = lockService.forceReleaseLock(path);
    assertTrue(result.isSuccess());
    assertEquals(path,
                 result.getLockInfo().getFile());
    assertEquals(null,
                 result.getLockInfo().lockedBy());
    assertFalse(result.getLockInfo().isLocked());
}
 

import org.uberfire.backend.vfs.Path; //导入依赖的package包/类
@Test
public void testInitRepositoryStructure1ClashingGAV() {
    final GAV gav = new GAV("groupId",
                            "artifactId",
                            "version");
    final Repository repository = mock(Repository.class);
    final Path repositoryRootPath = mock(Path.class);
    when(repository.getAlias()).thenReturn("alias");
    when(repository.getRoot()).thenReturn(repositoryRootPath);

    when(repositoryResolver.getRepositoriesResolvingArtifact(eq(gav))).thenReturn(new HashSet<MavenRepositoryMetadata>() {
        {
            add(new MavenRepositoryMetadata("local-id",
                                            "local-url",
                                            MavenRepositorySource.LOCAL));
        }
    });

    try {
        service.initRepositoryStructure(gav,
                                        repository,
                                        DeploymentMode.VALIDATED);
    } catch (GAVAlreadyExistsException expected) {
        //This is expected, but we want to verify the other services are not called
    }

    verify(repositoryResolver,
           times(1)).getRepositoriesResolvingArtifact(eq(gav));

    verify(pomService,
           never()).create(eq(repositoryRootPath),
                           eq(""),
                           any(POM.class));
    verify(m2service,
           never()).deployParentPom(eq(gav));
}