/**
   * Tries to delete an open project containing an irremovable file. Works only for Linux with
   * natives.
   */
  public void testDeleteOpenProjectLinux() {
    if (!(Platform.getOS().equals(Platform.OS_LINUX) && isReadOnlySupported())) return;

    IProject project = null;
    File projectRoot = null;
    IFolder folder = null;
    try {
      IWorkspace workspace = getWorkspace();
      project = workspace.getRoot().getProject(getUniqueString());
      folder = project.getFolder("a_folder");
      IFile file1 = folder.getFile("file1.txt");
      IFile file2 = project.getFile("file2.txt");

      ensureExistsInWorkspace(new IResource[] {file1, file2}, true);
      projectRoot = project.getLocation().toFile();

      // marks folder as read-only so its files cannot be deleted on Linux
      setReadOnly(folder, true);

      IFile projectFile = project.getFile(".project");
      assertTrue("1.2", projectFile.exists());
      assertTrue("1.3", projectFile.isSynchronized(IResource.DEPTH_INFINITE));

      try {
        project.delete(IResource.FORCE, getMonitor());
        fail("2.0 - should have failed");
      } catch (CoreException ce) {
        // success - a file couldn't be removed
      }
      assertTrue("2.1", project.exists());
      assertTrue("2.2", file1.exists());
      assertTrue("2.3", !file2.exists());
      assertTrue("2.5", folder.exists());
      assertTrue("2.6", projectFile.exists());
      assertTrue("2.7", project.isSynchronized(IResource.DEPTH_INFINITE));

      setReadOnly(folder, false);

      assertTrue("3.5", project.isSynchronized(IResource.DEPTH_INFINITE));
      try {
        project.delete(IResource.FORCE, getMonitor());
      } catch (CoreException ce) {
        ce.printStackTrace();
        fail("4.0", ce);
      }

      assertTrue("5.1", !project.exists());
      assertTrue("5.2", !file1.exists());
      assertTrue("5.3", file1.isSynchronized(IResource.DEPTH_INFINITE));
      assertTrue("5.4", project.isSynchronized(IResource.DEPTH_INFINITE));

      assertTrue("6.0", !projectRoot.exists());
    } finally {
      if (folder != null && folder.exists()) setReadOnly(folder, false);
      if (projectRoot != null) ensureDoesNotExistInFileSystem(projectRoot);
    }
  }
 /*
  * @see TestCase#setUp()
  */
 protected void setUp() throws Exception {
   super.setUp();
   setAutoBuilding(true);
   IWorkspaceRoot root = getWorkspace().getRoot();
   project1 = root.getProject("Project1");
   project2 = root.getProject("Project2");
   project3 = root.getProject("Project3");
   project4 = root.getProject("Project4");
   file1 = project1.getFile("File1");
   file2 = project2.getFile("File2");
   file3 = project3.getFile("File3");
   file4 = project4.getFile("File4");
   IResource[] resources = {project1, project2, project3, project4, file1, file2, file3, file4};
   ensureExistsInWorkspace(resources, true);
 }
  public void testMoveProjectWithVirtualFolder() {
    IPath fileLocation = getRandomLocation();
    IPath folderLocation = getRandomLocation();

    IFile file = existingVirtualFolderInExistingProject.getFile(getUniqueString());
    IFolder folder = existingVirtualFolderInExistingProject.getFolder(getUniqueString());
    IFile childFile = folder.getFile(getUniqueString());
    IResource[] oldResources = new IResource[] {existingProject, file, folder, childFile};

    try {
      assertDoesNotExistInWorkspace("1.0", new IResource[] {folder, file, childFile});

      try {
        createFileInFileSystem(fileLocation);
        folderLocation.toFile().mkdir();

        folder.createLink(folderLocation, IResource.NONE, getMonitor());
        file.createLink(fileLocation, IResource.NONE, getMonitor());

        childFile.create(getRandomContents(), true, getMonitor());
      } catch (CoreException e) {
        fail("2.0", e);
      }

      // move the project
      IProject destinationProject = getWorkspace().getRoot().getProject("MoveTargetProject");
      assertDoesNotExistInWorkspace("3.0", destinationProject);

      try {
        existingProject.move(destinationProject.getFullPath(), IResource.SHALLOW, getMonitor());
      } catch (CoreException e) {
        fail("4.0", e);
      }

      IFile newFile = destinationProject.getFile(file.getProjectRelativePath());
      IFolder newFolder = destinationProject.getFolder(folder.getProjectRelativePath());
      IFile newChildFile = newFolder.getFile(childFile.getName());
      IResource[] newResources =
          new IResource[] {destinationProject, newFile, newFolder, newChildFile};

      assertExistsInWorkspace("5.0", newResources);
      assertDoesNotExistInWorkspace("6.1", oldResources);
      assertTrue("7.0", existingProject.isSynchronized(IResource.DEPTH_INFINITE));
      assertTrue("8.0", destinationProject.isSynchronized(IResource.DEPTH_INFINITE));

      assertTrue("9.0", newFile.getParent().isVirtual());
      assertTrue("10.0", newFile.isLinked());

      assertTrue("11.0", newFolder.isLinked());
      assertTrue("12.0", newFolder.getParent().isVirtual());
    } finally {
      Workspace.clear(fileLocation.toFile());
      Workspace.clear(folderLocation.toFile());
    }
  }
  public void test01_prepareWorkspace() throws CoreException, URISyntaxException {
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    IProject project = workspace.getRoot().getProject("project");
    ensureExistsInWorkspace(project, true);

    IFile link = project.getFile("link_to_file");
    link.createLink(
        new URI("bug369177:/dummy_path.txt"), IResource.ALLOW_MISSING_LOCAL, getMonitor());

    workspace.save(true, getMonitor());
  }
예제 #5
0
 private IWARProduct createBasicProductWithLibraries() throws Exception {
   IWARProduct product = createBasicProduct();
   IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
   IProject project = wsRoot.getProject("warProduct");
   if (!project.exists()) {
     project.create(null);
     project.open(null);
   }
   IFile jar = project.getFile("test.jar");
   if (!jar.exists()) {
     File testJar = File.createTempFile("test", ".jar");
     FileInputStream stream = new FileInputStream(testJar);
     jar.create(stream, true, null);
   }
   product.addLibrary(jar.getFullPath(), false);
   IFile bridge = project.getFile(SERVLETBRIDGE + ".jar");
   if (!bridge.exists()) {
     File bridgeJar = File.createTempFile(SERVLETBRIDGE, ".jar");
     FileInputStream stream = new FileInputStream(bridgeJar);
     bridge.create(stream, true, null);
   }
   product.addLibrary(bridge.getFullPath(), false);
   return product;
 }
예제 #6
0
 public void testContainsServletBridgeLibrary() throws Exception {
   IWARProduct product = createBasicProduct();
   IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
   IProject project = wsRoot.getProject("warProduct");
   if (!project.exists()) {
     project.create(null);
     project.open(null);
   }
   IFile jar = project.getFile(SERVLETBRIDGE + ".jar");
   if (!jar.exists()) {
     File bridge = File.createTempFile(SERVLETBRIDGE, ".jar");
     FileInputStream stream = new FileInputStream(bridge);
     jar.create(stream, true, null);
   }
   product.addLibrary(jar.getFullPath(), false);
   Validator validator = new Validator(product);
   Validation validation = validator.validate();
   assertTrue(validation.isValid());
 }
  /** Test for Bug #5102. Never reproduced but interesting little test, worth keeping around */
  public void testPR() throws Exception {
    // create a project with a RefreshLocalJavaFileBuilder and a SortBuilder on the classpath
    IProject project = getWorkspace().getRoot().getProject("P1");
    project.create(null);
    project.open(null);
    IProjectDescription desc = project.getDescription();
    ICommand one = desc.newCommand();
    one.setBuilderName(RefreshLocalJavaFileBuilder.BUILDER_NAME);
    ICommand two = desc.newCommand();
    two.setBuilderName(SortBuilder.BUILDER_NAME);
    desc.setBuildSpec(new ICommand[] {one, two});
    project.setDescription(desc, null);

    // do a full build
    project.build(IncrementalProjectBuilder.FULL_BUILD, null);

    // do an incremental build by creating a file
    IFile file = project.getFile("Foo");
    file.create(getRandomContents(), true, getMonitor());
  }
  public void testCopyProjectWithVirtualFolder() {
    IPath fileLocation = getRandomLocation();
    IPath folderLocation = getRandomLocation();

    IFile linkedFile = existingVirtualFolderInExistingProject.getFile(getUniqueString());
    IFolder linkedFolder = existingVirtualFolderInExistingProject.getFolder(getUniqueString());

    try {
      try {
        createFileInFileSystem(fileLocation, getRandomContents());
        folderLocation.toFile().mkdir();

        linkedFolder.createLink(folderLocation, IResource.NONE, getMonitor());
        linkedFile.createLink(fileLocation, IResource.NONE, getMonitor());
      } catch (CoreException e) {
        fail("1.0", e);
      }

      // copy the project
      IProject destinationProject = getWorkspace().getRoot().getProject("CopyTargetProject");
      try {
        existingProject.copy(destinationProject.getFullPath(), IResource.SHALLOW, getMonitor());
      } catch (CoreException e) {
        fail("2.0", e);
      }

      IFile newFile = destinationProject.getFile(linkedFile.getProjectRelativePath());
      assertTrue("3.0", newFile.isLinked());
      assertEquals("3.1", linkedFile.getLocation(), newFile.getLocation());
      assertTrue("3.2", newFile.getParent().isVirtual());

      IFolder newFolder = destinationProject.getFolder(linkedFolder.getProjectRelativePath());
      assertTrue("4.0", newFolder.isLinked());
      assertEquals("4.1", linkedFolder.getLocation(), newFolder.getLocation());
      assertTrue("4.2", newFolder.getParent().isVirtual());

      // test project deep copy
      try {
        destinationProject.delete(IResource.NONE, getMonitor());
        existingProject.copy(destinationProject.getFullPath(), IResource.NONE, getMonitor());
      } catch (CoreException e) {
        fail("5.0", e);
      }

      assertTrue("5.1", newFile.isLinked());
      assertEquals("5.2", linkedFile.getLocation(), newFile.getLocation());
      assertTrue("5.3", newFile.getParent().isVirtual());
      assertTrue("5.4", newFolder.isLinked());
      assertEquals("5.5", linkedFolder.getLocation(), newFolder.getLocation());
      assertTrue("5.6", newFolder.getParent().isVirtual());

      try {
        destinationProject.delete(IResource.NONE, getMonitor());
      } catch (CoreException e) {
        fail("6.0", e);
      }
    } finally {
      Workspace.clear(fileLocation.toFile());
      Workspace.clear(folderLocation.toFile());
    }
  }
  /**
   * Creates a locale specific properties file within the fragment project based on the content of
   * the host plug-in's properties file.
   *
   * @param fragmentProject
   * @param locale
   * @throws CoreException
   * @throws IOException
   */
  private void createLocaleSpecificPropertiesFile(
      final IProject fragmentProject, IPluginModelBase plugin, final Locale locale)
      throws CoreException, IOException {
    final IFolder localeResourceFolder =
        fragmentProject.getFolder(RESOURCE_FOLDER_PARENT).getFolder(locale.toString());

    // Case 1: External plug-in
    if (plugin instanceof ExternalPluginModelBase) {
      final String installLocation = plugin.getInstallLocation();
      // Case 1a: External plug-in is a jar file
      if (new File(installLocation).isFile()) {
        ZipFile zf = new ZipFile(installLocation);
        for (Enumeration e = zf.entries(); e.hasMoreElements(); ) {
          worked();

          ZipEntry zfe = (ZipEntry) e.nextElement();
          String name = zfe.getName();

          String[] segments = name.split(SLASH);
          IPath path = Path.fromPortableString(join(SLASH, segments, 0, segments.length - 1));
          String resourceName = segments[segments.length - 1];
          String localizedResourceName = localeSpecificName(resourceName, locale);
          if (propertiesFilter.include(name)) {

            createParents(fragmentProject, path);
            IFile file = fragmentProject.getFile(path.append(localizedResourceName));
            InputStream is = zf.getInputStream(zfe);
            file.create(is, false, getProgressMonitor());
          } else if (resourceFilter.include(name)) {
            IPath target = localeResourceFolder.getFullPath().append(path).append(resourceName);
            createParents(fragmentProject, target.removeLastSegments(1).removeFirstSegments(1));
            IFile file = fragmentProject.getFile(target.removeFirstSegments(1));
            file.create(zf.getInputStream(zfe), false, getProgressMonitor());
          }
        }
      }
      // Case 1b: External plug-in has a folder structure
      else {
        Visitor visitor =
            new Visitor() {
              public void visit(File file) throws CoreException, FileNotFoundException {
                worked();

                String relativePath =
                    file.getAbsolutePath()
                        .substring(installLocation.length())
                        .replaceAll(File.separator, SLASH);
                String[] segments = relativePath.split(SLASH);
                IPath path = Path.fromPortableString(join(SLASH, segments, 0, segments.length - 1));
                String resourceName = segments[segments.length - 1];
                String localizedResourceName = localeSpecificName(resourceName, locale);

                if (propertiesFilter.include(
                    relativePath + (file.isDirectory() ? SLASH : EMPTY_STRING))) {
                  createParents(fragmentProject, path);
                  IFile iFile = fragmentProject.getFile(path.append(localizedResourceName));
                  iFile.create(new FileInputStream(file), false, getProgressMonitor());
                } else if (resourceFilter.include(
                    relativePath + (file.isDirectory() ? SLASH : EMPTY_STRING))) {
                  IPath target = localeResourceFolder.getFullPath().append(relativePath);
                  createParents(
                      fragmentProject, target.removeLastSegments(1).removeFirstSegments(1));
                  IFile iFile = fragmentProject.getFile(target.removeFirstSegments(1));
                  iFile.create(new FileInputStream(file), false, getProgressMonitor());
                }

                if (file.isDirectory()) {
                  File[] children = file.listFiles();
                  for (int i = 0; i < children.length; i++) {
                    visit(children[i]);
                  }
                }
              }
            };

        visitor.visit(new File(installLocation));
      }
    }
    // Case 2: Workspace plug-in
    else {
      final IProject project = plugin.getUnderlyingResource().getProject();

      project.accept(
          new IResourceVisitor() {
            public boolean visit(IResource resource) throws CoreException {
              worked();

              IPath parent = resource.getFullPath().removeLastSegments(1).removeFirstSegments(1);
              if (propertiesFilter.include(resource)) {
                String segment = localeSpecificName(resource.getFullPath().lastSegment(), locale);
                IPath fragmentResource =
                    fragmentProject.getFullPath().append(parent).append(segment);

                createParents(fragmentProject, parent);
                resource.copy(fragmentResource, true, getProgressMonitor());
              } else if (resourceFilter.include(resource)) {
                IPath target =
                    localeResourceFolder
                        .getFullPath()
                        .append(parent)
                        .append(resource.getFullPath().lastSegment());
                createParents(fragmentProject, target.removeLastSegments(1).removeFirstSegments(1));
                resource.copy(target, true, getProgressMonitor());
              }
              return true;
            }
          });
    }
  }
예제 #10
0
  /**
   * The worker method. It will create a new project, then create the appropriate Soar heirarchy and
   * files.
   */
  private void doFinish(String projectName, IProgressMonitor monitor) throws CoreException {

    monitor.beginTask("Creating " + projectName, 7);

    IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
    IProject newProject = root.getProject(projectName);

    // creation of the project
    if (newProject.exists()) {
      throwCoreException("Project \"" + projectName + "\" already exists");
    } else {

      newProject.create(monitor);
      newProject.open(monitor);

      try {

        IProjectDescription description = newProject.getDescription();
        String[] natures = description.getNatureIds();
        String[] newNatures = new String[natures.length + 1];
        System.arraycopy(natures, 0, newNatures, 0, natures.length);
        newNatures[natures.length] = SoarProjectNature.NATURE_ID;
        description.setNatureIds(newNatures);

        newProject.setDescription(description, IResource.FORCE, monitor);

        newProject.setPersistentProperty(DataMap.VERTEX_ID, "0");

      } catch (CoreException e) {
        e.printStackTrace();
      } // catch
    } // else

    monitor.worked(2);

    // Create the contents of the project's root directory
    IFolder folderAll = newProject.getFolder("all");
    if (!folderAll.exists()) {
      folderAll.create(true, true, monitor);
    } // if
    FileMarker.markResource(folderAll, "file");

    IFolder folderElaborations = newProject.getFolder("elaborations");
    if (!folderElaborations.exists()) {
      folderElaborations.create(true, true, monitor);
    } // if
    FileMarker.markResource(folderElaborations, "file");

    IFile file_firstload = newProject.getFile("_firstload.soar");
    if (!file_firstload.exists()) {
      file_firstload.create(
          Utility.getFileTemplate(file_firstload, "_firstload.soar"), true, monitor);
    } // if
    FileMarker.markResource(file_firstload, "file");

    IFile filedatamap = newProject.getFile("datamap.xdm");
    if (!filedatamap.exists()) {
      filedatamap.create(Utility.getFileTemplate(filedatamap, "datamap.xdm"), true, monitor);
    } // if

    monitor.worked(3);

    // Create the contents of the elaborations folder
    IFile file_all = folderElaborations.getFile("_all.soar");
    if (!file_all.exists()) {
      file_all.create(Utility.getFileTemplate(file_all, "_all.soar"), true, monitor);
    } // if
    FileMarker.markResource(file_all, "file");

    IFile filetopstate = folderElaborations.getFile("top-state.soar");
    if (!filetopstate.exists()) {
      filetopstate.create(Utility.getFileTemplate(filetopstate, "top-state.soar"), true, monitor);
    } // if
    FileMarker.markResource(filetopstate, "file");

    SourcingFile.createSourcingFile(newProject, monitor);

    newProject.close(monitor);
    newProject.open(monitor);

    monitor.worked(2);
    monitor.done();
  } // void doFinish(...)
  /** Tries to delete an open project containing an unremovable file. Works only for Windows. */
  public void testDeleteOpenProjectWindows() {
    if (!(isWindows())) return;

    IProject project = null;
    InputStream input = null;
    File projectRoot = null;
    try {
      IWorkspace workspace = getWorkspace();
      project = workspace.getRoot().getProject(getUniqueString());
      IFolder folder = project.getFolder("a_folder");
      IFile file1 = folder.getFile("file1.txt");
      IFile file2 = project.getFile("file2.txt");
      IFile file3 = folder.getFile("file3.txt");
      IFile projectFile = project.getFile(new Path(".project"));

      ensureExistsInWorkspace(new IResource[] {file1, file2, file3}, true);
      projectRoot = project.getLocation().toFile();

      assertExistsInFileSystem("0.0", file1);
      assertExistsInFileSystem("0.1", file2);
      assertExistsInFileSystem("0.2", file3);
      assertExistsInFileSystem("0.3", folder);
      assertExistsInFileSystem("0.4", projectFile);

      // opens a file so it cannot be removed on Windows
      try {
        input = file1.getContents();
      } catch (CoreException ce) {
        ce.printStackTrace();
        fail("1.0");
      }
      assertTrue("1.2", projectFile.exists());
      assertTrue("1.3", projectFile.isSynchronized(IResource.DEPTH_INFINITE));

      try {
        project.delete(IResource.FORCE, getMonitor());
        fail("2.0 - should have failed");
      } catch (CoreException ce) {
        // success - a file couldn't be removed
      }

      // Delete is best-case so check all the files.
      // Do a check on disk and in the workspace in case something is out of sync.
      assertExistsInWorkspace("2.1.1", project);
      assertExistsInFileSystem("2.1.2", project);

      assertExistsInWorkspace("2.2.1", file1);
      assertExistsInFileSystem("2.2.2", file1);
      assertTrue("2.2.3", file1.isSynchronized(IResource.DEPTH_INFINITE));

      assertDoesNotExistInWorkspace("2.3.1", file2);
      assertDoesNotExistInFileSystem("2.3.2", file2);
      assertTrue("2.3.3", file2.isSynchronized(IResource.DEPTH_INFINITE));

      assertDoesNotExistInWorkspace("2.4.1", file3);
      assertDoesNotExistInFileSystem("2.4.2", file3);
      assertTrue("2.4.3", file3.isSynchronized(IResource.DEPTH_INFINITE));

      assertExistsInWorkspace("2.5.1", folder);
      assertExistsInFileSystem("2.5.2", folder);
      assertTrue("2.5.3", folder.isSynchronized(IResource.DEPTH_INFINITE));

      assertExistsInWorkspace("2.6.1", projectFile);
      assertExistsInFileSystem("2.6.2", projectFile);
      assertTrue("2.6.3", projectFile.isSynchronized(IResource.DEPTH_INFINITE));

      assertTrue("2.7.0", project.isSynchronized(IResource.DEPTH_ZERO));
      assertTrue("2.7.1", project.isSynchronized(IResource.DEPTH_INFINITE));

      assertClose(input);

      assertTrue("3.5", project.isSynchronized(IResource.DEPTH_INFINITE));
      try {
        project.delete(IResource.FORCE, getMonitor());
      } catch (CoreException e) {
        fail("4.0", e);
      }

      assertTrue("5.1", !project.exists());
      assertTrue("5.2", !file1.exists());
      assertTrue("5.3", file1.isSynchronized(IResource.DEPTH_INFINITE));
      assertTrue("5.4", project.isSynchronized(IResource.DEPTH_INFINITE));

      assertTrue("6.0", !projectRoot.exists());
    } finally {
      try {
        assertClose(input);
      } finally {
        if (projectRoot != null) ensureDoesNotExistInFileSystem(projectRoot);
      }
    }
  }
  /** Tries to delete a closed project containing an unremovable file. Works only for Windows. */
  public void testDeleteClosedProjectWindows() {
    if (!isWindows()) return;

    IProject project = null;
    InputStream input = null;
    File projectRoot = null;
    IFile file1 = null;
    try {
      IWorkspace workspace = getWorkspace();
      project = workspace.getRoot().getProject(getUniqueString());
      IFolder folder = project.getFolder("a_folder");
      file1 = folder.getFile("file1.txt");
      IFile file2 = project.getFile("file2.txt");
      IFile file3 = folder.getFile("file3.txt");
      IFile projectFile = project.getFile(new Path(".project"));

      ensureExistsInWorkspace(new IResource[] {file1, file2, file3}, true);

      projectRoot = project.getLocation().toFile();

      // opens a file so it cannot be removed on Windows
      try {
        input = file1.getContents();
      } catch (CoreException ce) {
        ce.printStackTrace();
        fail("1.0");
      }

      try {
        project.close(getMonitor());
      } catch (CoreException e) {
        fail("1.1", e);
      }

      try {
        project.delete(IResource.FORCE | IResource.ALWAYS_DELETE_PROJECT_CONTENT, getMonitor());
        fail("2.0 - should have failed");
      } catch (CoreException ce) {
        // success - a file couldn't be removed
      }
      assertTrue("2.1", project.exists());
      assertTrue("2.7", project.isSynchronized(IResource.DEPTH_INFINITE));
      assertExistsInFileSystem("2.8", projectFile);

      assertClose(input);
      assertTrue("3.5", project.isSynchronized(IResource.DEPTH_INFINITE));
      try {
        project.delete(IResource.FORCE | IResource.ALWAYS_DELETE_PROJECT_CONTENT, getMonitor());
      } catch (CoreException ce) {
        ce.printStackTrace();
        fail("4.0", ce);
      }

      assertTrue("5.1", !project.exists());
      assertTrue("5.3", project.isSynchronized(IResource.DEPTH_INFINITE));
      assertTrue("6.0", !projectRoot.exists());
      assertDoesNotExistInFileSystem("7.0", projectFile);
    } finally {
      try {
        if (input != null) input.close();
      } catch (IOException e) {
        fail("8.0", e);
      } finally {
        if (projectRoot != null) ensureDoesNotExistInFileSystem(projectRoot);
      }
    }
  }
예제 #13
0
 private IFile getSettingsFile() {
   return _project.getFile(SETTINGS_FILE);
 }