Example usage for org.eclipse.jdt.core IJavaElement PACKAGE_FRAGMENT_ROOT

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IJavaElement PACKAGE_FRAGMENT_ROOT.

Prototype

int PACKAGE_FRAGMENT_ROOT

To view the source code for org.eclipse.jdt.core IJavaElement PACKAGE_FRAGMENT_ROOT.

Click Source Link

Document

Constant representing a package fragment root.

Usage

From source file:org.grails.ide.eclipse.editor.gsp.translation.GSPTranslation.java

License:Open Source License

/**
 * Originally from ReconcileStepForJava.  Creates an ICompilationUnit from the contents of the JSP document.
 * /* ww w.j av a  2  s .  com*/
 * @return an ICompilationUnit from the contents of the JSP document
 */
private ICompilationUnit createCompilationUnit() throws JavaModelException {

    IPackageFragment packageFragment = null;
    IJavaElement je = getJavaProject();

    if (je == null || !je.exists())
        return null;

    switch (je.getElementType()) {
    case IJavaElement.PACKAGE_FRAGMENT:
        je = je.getParent();
        // fall through

    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) je;
        packageFragment = packageFragmentRoot.getPackageFragment(IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH);
        break;

    case IJavaElement.JAVA_PROJECT:
        IJavaProject jProject = (IJavaProject) je;

        if (!jProject.exists()) {
            if (DEBUG) {
                System.out.println(
                        "** Abort create working copy: cannot create working copy: JSP is not in a Java project"); //$NON-NLS-1$
            }
            return null;
        }

        packageFragmentRoot = null;
        IPackageFragmentRoot[] packageFragmentRoots = jProject.getPackageFragmentRoots();
        int i = 0;
        while (i < packageFragmentRoots.length) {
            if (!packageFragmentRoots[i].isArchive() && !packageFragmentRoots[i].isExternal()) {
                packageFragmentRoot = packageFragmentRoots[i];
                break;
            }
            i++;
        }
        if (packageFragmentRoot == null) {
            if (DEBUG) {
                System.out.println(
                        "** Abort create working copy: cannot create working copy: JSP is not in a Java project with source package fragment root"); //$NON-NLS-1$
            }
            return null;
        }
        packageFragment = packageFragmentRoot.getPackageFragment(IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH);
        break;

    default:
        return null;
    }

    // GRAILS CHANGE
    // create compilation unit with .groovy instead of .java file extension
    ICompilationUnit cu = packageFragment.getCompilationUnit(getClassname() + ".groovy") //$NON-NLS-1$
            .getWorkingCopy(getWorkingCopyOwner(), getProgressMonitor());
    //        ICompilationUnit cu = packageFragment.getCompilationUnit(getClassname() + ".java").getWorkingCopy(getWorkingCopyOwner(), getProgressMonitor()); //$NON-NLS-1$
    setContents(cu);

    // GRAILS CHANGE
    // need extra call to makeConsistent
    // https://issuetracker.springsource.com/browse/STS-3091#comment-79054
    cu.makeConsistent(getProgressMonitor());

    if (DEBUG) {
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"); //$NON-NLS-1$
        System.out.println("(+) JSPTranslation [" + this + "] finished creating CompilationUnit: " + cu); //$NON-NLS-1$ //$NON-NLS-2$
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"); //$NON-NLS-1$
    }

    return cu;
}

---

From source file:org.grails.ide.eclipse.test.Grails20JUnitIntegrationTests.java

License:Open Source License

public void testTestFinderFindTest() throws Exception {
    ITestFinder testFinder = getJUnit4TestFinder();

    createTmpResource(project, "test/unit/" + packageName + "/Helper.groovy",
            "package " + packageName + "\n" + "\n" + "class Helper {\n" + "\n" + "   void help() {\n"
                    + "      println 'help!'\n" + "   }\n" + "}");
    StsTestUtil.waitForAutoBuild();/*from  www.j a  va  2  s  .co m*/
    IType clazz = javaProject.findType(packageName + ".Helper");
    assertNotNull(clazz);

    //1) Search in a cu that doesn't have a test class inside.
    Set<Object> result = new HashSet<Object>();
    testFinder.findTestsInContainer(clazz.getCompilationUnit(), result, new NullProgressMonitor());
    assertEquals(0, result.size());

    //2) Search in a cu that does have a test class inside
    result = new HashSet<Object>();
    clazz = javaProject.findType(testDomainClassName);
    testFinder.findTestsInContainer(clazz.getCompilationUnit(), result, new NullProgressMonitor());
    GrailsTest.assertElements(result, clazz);

    //3) Search in test/unit package fragment root
    result = new HashSet<Object>();
    IJavaElement pfr = clazz.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
    testFinder.findTestsInContainer(pfr, result, new NullProgressMonitor());
    GrailsTest.assertElements(result, clazz);

    //4) Same as above, but add an extra test class to see if that's also found.
    createTmpResource(project, "test/unit/" + packageName + "/FoobarTests.groovy",
            "package grails20junitintegrationtests\n" + "\n" + "import grails.test.mixin.*\n" + "\n"
                    + "@TestFor(" + domainClassBaseName + ")\n" + "class FoobarTests {\n" + "\n"
                    + "   void testThisAndThat() {\n" + "      assertEquals 4, 4\n" + "   }\n" + "   \n" + "}");
    StsTestUtil.waitForAutoBuild();
    IType extraTestClass = javaProject.findType(packageName + ".FoobarTests");
    testFinder.findTestsInContainer(pfr, result, new NullProgressMonitor());
    GrailsTest.assertElements(result, clazz, extraTestClass);

    //5) One more time, now search the whole project
    result = new HashSet<Object>();
    testFinder.findTestsInContainer(javaProject, result, new NullProgressMonitor());
    GrailsTest.assertElements(result, clazz, extraTestClass);
}

---

From source file:org.grails.ide.eclipse.test.util.AbstractGrailsJUnitIntegrationsTest.java

License:Open Source License

/**
 * COPIED from JUnitLaunchShortcut... create a JUnit lauch config just like the one the JUnit UI would.
 *///from   w  w w  .j  ava  2 s  .  c o  m
public static ILaunchConfigurationWorkingCopy createLaunchConfiguration(IJavaElement element)
        throws CoreException {
    final String testName;
    final String mainTypeQualifiedName;
    final String containerHandleId;

    switch (element.getElementType()) {
    case IJavaElement.JAVA_PROJECT:
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
    case IJavaElement.PACKAGE_FRAGMENT: {
        String name = element.getElementName();
        containerHandleId = element.getHandleIdentifier();
        mainTypeQualifiedName = "";
        testName = name.substring(name.lastIndexOf(IPath.SEPARATOR) + 1);
    }
        break;
    case IJavaElement.TYPE: {
        containerHandleId = "";
        mainTypeQualifiedName = ((IType) element).getFullyQualifiedName('.'); // don't replace, fix for binary inner types
        testName = element.getElementName();
    }
        break;
    case IJavaElement.METHOD: {
        IMethod method = (IMethod) element;
        containerHandleId = "";
        mainTypeQualifiedName = method.getDeclaringType().getFullyQualifiedName('.');
        testName = method.getDeclaringType().getElementName() + '.' + method.getElementName();
    }
        break;
    default:
        throw new IllegalArgumentException(
                "Invalid element type to create a launch configuration: " + element.getClass().getName()); //$NON-NLS-1$
    }

    String testKindId = TestKindRegistry.getContainerTestKindId(element);

    ILaunchConfigurationType configType = getLaunchManager()
            .getLaunchConfigurationType(JUnitLaunchConfigurationConstants.ID_JUNIT_APPLICATION);
    ILaunchConfigurationWorkingCopy wc = configType.newInstance(null,
            getLaunchManager().generateLaunchConfigurationName(testName));

    wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, mainTypeQualifiedName);
    wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME,
            element.getJavaProject().getElementName());
    wc.setAttribute(JUnitLaunchConfigurationConstants.ATTR_KEEPRUNNING, false);
    wc.setAttribute(JUnitLaunchConfigurationConstants.ATTR_TEST_CONTAINER, containerHandleId);
    wc.setAttribute(JUnitLaunchConfigurationConstants.ATTR_TEST_RUNNER_KIND, testKindId);
    JUnitMigrationDelegate.mapResources(wc);
    //AssertionVMArg.setArgDefault(wc);
    if (element instanceof IMethod) {
        wc.setAttribute(JUnitLaunchConfigurationConstants.ATTR_TEST_METHOD_NAME, element.getElementName()); // only set for methods
    }
    return wc;
}

---

From source file:org.grails.ide.eclipse.ui.internal.launch.GrailsTestLaunchShortcut.java

License:Open Source License

@Override
protected String getScriptFor(IResource resource) {
    if (GrailsResourceUtil.isTestFolder(resource)) {
        String script = TEST_APP + " -" + resource.getName();
        System.out.println("grails command = " + script);
        return script;
    } else {/*from   w w w . java2  s .c o m*/
        String script = TEST_APP;
        String testType = GrailsResourceUtil.typeOfTest(resource);
        if (testType != null) {
            script += " -" + testType;
        }
        if (GrailsResourceUtil.isSourceFile(resource)) {
            IJavaElement javaElement = JavaCore.create(resource);
            if (javaElement != null) {
                int elementType = javaElement.getElementType();
                switch (elementType) {
                case IJavaElement.PACKAGE_FRAGMENT:
                    IPackageFragment pkg = (IPackageFragment) javaElement;
                    script += " " + pkg.getElementName() + ".*";
                    break;
                case IJavaElement.COMPILATION_UNIT:
                    String pathIncludingSourceFolder = resource.getProjectRelativePath().toString();
                    IPackageFragmentRoot sourceRoot = (IPackageFragmentRoot) javaElement
                            .getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
                    String sourceFolderPath = sourceRoot.getResource().getProjectRelativePath().toString();
                    Assert.isTrue(pathIncludingSourceFolder.startsWith(sourceFolderPath + "/"));
                    String pathWithoutSourceFolder = pathIncludingSourceFolder
                            .substring(sourceFolderPath.length() + 1);
                    if (isRecentGrails(resource.getProject())) {
                        pathWithoutSourceFolder = removeSuffix(pathWithoutSourceFolder, ".groovy");
                    } else {
                        pathWithoutSourceFolder = removeSuffix(pathWithoutSourceFolder, "Test.groovy",
                                "Tests.groovy", ".groovy");
                    }
                    if (pathWithoutSourceFolder != null) {
                        String testTarget = pathWithoutSourceFolder.replace('/', '.');
                        script += " " + testTarget;
                    }
                default:
                    break;
                }
            }
        }
        debug("grails command = " + script);
        return script;
    }
}

---

From source file:org.granite.builder.util.ProjectUtil.java

License:Open Source License

public static JavaClassInfo getJavaClassInfo(IJavaProject project, IFile resource) throws CoreException {
    // classPath = "<project name>/<output folder>/<package>/<file>.class"
    IPath classPath = resource.getFullPath().makeRelative();

    // Find output folder: "<project name>/<output folder>".
    IPath outputFolder = null;//from w w w .j  a v  a 2 s .  c  om
    if (project.getOutputLocation() != null && project.getOutputLocation().isPrefixOf(classPath))
        outputFolder = project.getOutputLocation();
    else {
        for (IClasspathEntry cpe : project.getRawClasspath()) {
            if (cpe.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
                IPath output = cpe.getOutputLocation();
                if (output != null && output.isPrefixOf(classPath)) {
                    outputFolder = output;
                    break;
                }
            }
        }
    }

    if (outputFolder == null)
        return null;

    // Compute class name.
    IPath relativeClassPath = classPath.removeFirstSegments(outputFolder.segmentCount());
    IPath relativeClassName = relativeClassPath.removeFileExtension();
    String className = relativeClassName.toPortableString().replace('/', '.');

    // Compute java source path: "<package>/<class name>[$<inner class>].java".
    String javaFullPath = relativeClassName.addFileExtension("java").toPortableString();
    String javaFilePath = javaFullPath;
    int iDollar = javaFilePath.indexOf('$');
    if (iDollar != -1)
        javaFilePath = javaFilePath.substring(0, iDollar) + ".java";

    IJavaElement javaElement = project.findElement(new Path(javaFilePath));
    if (javaElement == null)
        return null;

    IJavaElement sourceFolder = javaElement.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
    if (sourceFolder == null)
        return null;

    IPath folderPath = sourceFolder.getPath().makeRelative();
    if (folderPath.segmentCount() > 0)
        folderPath = folderPath.removeFirstSegments(1);

    // Fix issues with project not in the workspace directory.
    outputFolder = project.getProject().getWorkspace().getRoot().findMember(outputFolder).getLocation();

    return new JavaClassInfo(folderPath.toPortableString(), javaFullPath, className,
            new File(outputFolder.toPortableString(), relativeClassPath.toPortableString()));
}

---

From source file:org.jaml.eclipse.editors.JamlContentAssistProcessor.java

License:Open Source License

private IJavaElement getHighestRoot(IJavaElement element) {
    return element.getElementType() != IJavaElement.PACKAGE_FRAGMENT_ROOT
            && element.getElementType() != IJavaElement.JAVA_PROJECT && element.getParent() != null
                    ? getHighestRoot(element.getParent())
                    : element;/*ww  w . j  a va 2  s .  com*/
}

---

From source file:org.jaml.eclipse.utils.JDTUtils.java

License:Open Source License

public static void findJavaTypes(List<IType> list, IJavaElement element) throws JavaModelException {
    switch (element.getElementType()) {
    case IJavaElement.JAVA_PROJECT:
        // Java project
        IJavaProject proj = (IJavaProject) element;
        findJavaTypes(list, proj.getChildren());
        break;/*from  w ww  .  j a v a2s  .c  o m*/
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        // JAR file
        IPackageFragmentRoot pkgRoot = (IPackageFragmentRoot) element;
        findJavaTypes(list, pkgRoot.getChildren());
        break;
    case IJavaElement.PACKAGE_FRAGMENT:
        // Java package
        IPackageFragment pkgFragment = (IPackageFragment) element;
        findJavaTypes(list, pkgFragment.getChildren());
        break;
    case IJavaElement.COMPILATION_UNIT:
        // Source file (.java)
        ICompilationUnit cmUnit = (ICompilationUnit) element;
        findJavaTypes(list, cmUnit.getTypes());
        break;
    case IJavaElement.CLASS_FILE:
        // Compiled file (.class)
        IClassFile clFile = (IClassFile) element;
        findJavaTypes(list, clFile.getType());
        break;
    case IJavaElement.TYPE:
        // Java class
        IType type = (IType) element;
        if (!type.getFullyQualifiedName().contains("$")) {
            list.add(type);
        }
        break;
    }
}

---

From source file:org.jaml.eclipse.utils.JDTUtils.java

License:Open Source License

public static String getIJavaElementPath(IJavaElement element) throws JavaModelException {
    switch (element.getElementType()) {
    case IJavaElement.JAVA_PROJECT:
        return element.getCorrespondingResource().getFullPath().toString();
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        return element.getCorrespondingResource().getFullPath().toString();
    case IJavaElement.PACKAGE_FRAGMENT:
        return element.getCorrespondingResource().getFullPath().toString();
    case IJavaElement.COMPILATION_UNIT:
        return element.getCorrespondingResource().getFullPath().toString().replace(element.getElementName(),
                "");
    case IJavaElement.TYPE:
        return getIJavaElementPath(element.getParent());
    }//www  . j a v  a  2  s.c om
    return JavaExt.STRING_EMPTY;
}

---

From source file:org.jboss.tools.arquillian.ui.internal.commands.ArquillianPropertyTester.java

License:Open Source License

private boolean canLaunchAsArquillianJUnitTest(IJavaElement element) {
    try {//w ww  .ja  v  a  2 s  . c  om
        switch (element.getElementType()) {
        case IJavaElement.JAVA_PROJECT:
        case IJavaElement.PACKAGE_FRAGMENT_ROOT:
            return true; // can run, let test runner detect if there are tests
        case IJavaElement.PACKAGE_FRAGMENT:
            return ((IPackageFragment) element).hasChildren();
        case IJavaElement.COMPILATION_UNIT:
        case IJavaElement.CLASS_FILE:
        case IJavaElement.TYPE:
        case IJavaElement.METHOD:
            return ArquillianSearchEngine.isArquillianJUnitTest(element, true, true, false);
        default:
            return false;
        }
    } catch (JavaModelException e) {
        return false;
    }
}

---

From source file:org.jboss.tools.arquillian.ui.internal.launcher.ArquillianLaunchShortcut.java

License:Open Source License

private void launch(Object[] elements, String mode) {
    try {//w w  w  .  java 2  s . c  o  m
        IJavaElement elementToLaunch = null;

        if (elements.length == 1) {
            Object selected = elements[0];
            if (!(selected instanceof IJavaElement) && selected instanceof IAdaptable) {
                selected = ((IAdaptable) selected).getAdapter(IJavaElement.class);
            }
            if (selected instanceof IJavaElement) {
                IJavaElement element = (IJavaElement) selected;
                switch (element.getElementType()) {
                case IJavaElement.JAVA_PROJECT:
                case IJavaElement.PACKAGE_FRAGMENT_ROOT:
                case IJavaElement.PACKAGE_FRAGMENT:
                    IJavaProject javaProject = element.getJavaProject();
                    if (ArquillianSearchEngine.hasArquillianType(javaProject)) {
                        elementToLaunch = element;
                    }
                    break;
                case IJavaElement.TYPE:
                    IType type = (IType) element;
                    if (ArquillianSearchEngine.isArquillianJUnitTest(type, true, true)) {
                        elementToLaunch = type;
                    }
                case IJavaElement.METHOD:
                    javaProject = element.getJavaProject();
                    if (ArquillianSearchEngine.hasArquillianType(javaProject)) {
                        elementToLaunch = element;
                    }
                    break;
                case IJavaElement.CLASS_FILE:
                    type = ((IClassFile) element).getType();
                    if (ArquillianSearchEngine.isArquillianJUnitTest(type, true, true, false)) {
                        elementToLaunch = type;
                    }
                    break;
                case IJavaElement.COMPILATION_UNIT:
                    elementToLaunch = findTypeToLaunch((ICompilationUnit) element, mode);
                    break;
                }
            }
        }
        if (elementToLaunch == null) {
            showNoTestsFoundDialog();
            return;
        }
        performLaunch(elementToLaunch, mode);
    } catch (InterruptedException e) {
        // OK, silently move on
    } catch (CoreException e) {
        ExceptionHandler.handle(e, getShell(), ARQUILLIAN_J_UNIT_LAUNCH,
                LAUNCHING_OF_ARQILLIAN_J_UNIT_TESTS_FAILED);
    } catch (InvocationTargetException e) {
        ExceptionHandler.handle(e, getShell(), ARQUILLIAN_J_UNIT_LAUNCH,
                LAUNCHING_OF_ARQILLIAN_J_UNIT_TESTS_FAILED);
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• »