| /******************************************************************************* |
| * Copyright (c) 2000, 2012 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jdt.debug.tests.core; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.debug.core.ILaunchConfiguration; |
| import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.debug.testplugin.JavaProjectHelper; |
| import org.eclipse.jdt.debug.tests.AbstractDebugTest; |
| import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants; |
| import org.eclipse.jdt.launching.IRuntimeClasspathEntry; |
| import org.eclipse.jdt.launching.IRuntimeClasspathProvider; |
| import org.eclipse.jdt.launching.JavaRuntime; |
| import org.eclipse.jdt.launching.environments.IExecutionEnvironment; |
| |
| /** |
| * Tests runtime classpath provider extension point |
| */ |
| public class ClasspathProviderTests extends AbstractDebugTest { |
| |
| public ClasspathProviderTests(String name) { |
| super(name); |
| } |
| |
| public void testEmptyProvider() throws Exception { |
| ILaunchConfiguration config = getLaunchConfiguration("Breakpoints"); |
| ILaunchConfigurationWorkingCopy wc = config.getWorkingCopy(); |
| |
| wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_CLASSPATH_PROVIDER, "org.eclipse.jdt.debug.tests.EmptyClasspathProvider"); |
| wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_SOURCE_PATH_PROVIDER, "org.eclipse.jdt.debug.tests.EmptyClasspathProvider"); |
| |
| IRuntimeClasspathProvider cpProvider = JavaRuntime.getClasspathProvider(wc); |
| IRuntimeClasspathProvider spProvider = JavaRuntime.getSourceLookupPathProvider(wc); |
| |
| assertNotNull("Did not retrieve classpath provider", cpProvider); |
| assertNotNull("Did not retrieve source path provider", spProvider); |
| |
| assertEquals("Classpath should be empty", 0, cpProvider.computeUnresolvedClasspath(config).length); |
| assertEquals("Source path should be empty", 0, spProvider.computeUnresolvedClasspath(config).length); |
| } |
| |
| /** |
| * Test that a variable set to the location of an archive resolves properly. |
| */ |
| public void testVariableArchiveResolution() throws Exception { |
| IResource archive = get14Project().getProject().getFolder("src").getFile("A.jar"); |
| assertTrue("Archive does not exist", archive.exists()); |
| String varName = "COMPLETE_ARCHIVE"; |
| JavaCore.setClasspathVariable(varName, archive.getFullPath(), null); |
| |
| IRuntimeClasspathEntry runtimeClasspathEntry = JavaRuntime.newVariableRuntimeClasspathEntry(new Path(varName)); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(runtimeClasspathEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", archive.getFullPath(), resolved[0].getPath()); |
| assertEquals("Resolved path not correct", archive.getLocation(), new Path(resolved[0].getLocation())); |
| } |
| |
| /** |
| * Test that a variable set to the location of an archive via variable |
| * extension resolves properly. |
| */ |
| public void testVariableExtensionResolution() throws Exception { |
| IResource archive = get14Project().getProject().getFolder("src").getFile("A.jar"); |
| IProject root = get14Project().getProject(); |
| String varName = "RELATIVE_ARCHIVE"; |
| JavaCore.setClasspathVariable(varName, root.getFullPath(), null); |
| |
| IRuntimeClasspathEntry runtimeClasspathEntry = JavaRuntime.newVariableRuntimeClasspathEntry(new Path(varName).append(new Path("src")).append(new Path("A.jar"))); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(runtimeClasspathEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", archive.getFullPath(), resolved[0].getPath()); |
| assertEquals("Resolved path not correct", archive.getLocation(), new Path(resolved[0].getLocation())); |
| } |
| |
| // BOOTPATH TESTS |
| |
| /** |
| * Test that a variable added to the bootpath is resolved to be on the bootpath. |
| */ |
| public void testBootpathVariableResolution() throws Exception { |
| IResource archive = get14Project().getProject().getFolder("src").getFile("A.jar"); |
| assertTrue("Archive does not exist", archive.exists()); |
| String varName = "bootpathVar"; |
| JavaCore.setClasspathVariable(varName, archive.getFullPath(), null); |
| |
| IRuntimeClasspathEntry runtimeClasspathEntry = JavaRuntime.newVariableRuntimeClasspathEntry(new Path(varName)); |
| runtimeClasspathEntry.setClasspathProperty(IRuntimeClasspathEntry.BOOTSTRAP_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(runtimeClasspathEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", archive.getFullPath(), resolved[0].getPath()); |
| assertEquals("Resolved path not correct", archive.getLocation(), new Path(resolved[0].getLocation())); |
| assertEquals("Resolved entry should be on bootpath", IRuntimeClasspathEntry.BOOTSTRAP_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that an extended variable added to the bootpath is resolved to be on the bootpath. |
| */ |
| public void testBootpathVariableExtensionResolution() throws Exception { |
| IResource archive = get14Project().getProject().getFolder("src").getFile("A.jar"); |
| IProject root = get14Project().getProject(); |
| String varName = "bootpathVarRoot"; |
| JavaCore.setClasspathVariable(varName, root.getFullPath(), null); |
| |
| IRuntimeClasspathEntry runtimeClasspathEntry = JavaRuntime.newVariableRuntimeClasspathEntry(new Path(varName).append(new Path("src")).append(new Path("A.jar"))); |
| runtimeClasspathEntry.setClasspathProperty(IRuntimeClasspathEntry.BOOTSTRAP_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(runtimeClasspathEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", archive.getFullPath(), resolved[0].getPath()); |
| assertEquals("Resolved path not correct", archive.getLocation(), new Path(resolved[0].getLocation())); |
| assertEquals("Resolved entry should be on bootpath", IRuntimeClasspathEntry.BOOTSTRAP_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that a project added to the bootpath is resolved to be on the bootpath. |
| */ |
| public void testBootpathProjectResolution() throws Exception { |
| IJavaProject project = get14Project(); |
| IResource outputFolder = ResourcesPlugin.getWorkspace().getRoot().findMember(project.getOutputLocation()); |
| |
| IRuntimeClasspathEntry runtimeClasspathEntry = JavaRuntime.newProjectRuntimeClasspathEntry(project); |
| runtimeClasspathEntry.setClasspathProperty(IRuntimeClasspathEntry.BOOTSTRAP_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(runtimeClasspathEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", outputFolder.getLocation().toOSString(), resolved[0].getLocation()); |
| assertEquals("Resolved entry should be on bootpath", IRuntimeClasspathEntry.BOOTSTRAP_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that a container added to the bootpath is resolved to have all entries on |
| * the boothpath. |
| */ |
| public void testBootpathContainerResolution() throws Exception { |
| IRuntimeClasspathEntry entry = JavaRuntime.newRuntimeContainerClasspathEntry(new Path(JavaRuntime.JRE_CONTAINER), IRuntimeClasspathEntry.BOOTSTRAP_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(entry, get14Project()); |
| // each resolved entry should be on the bootpath |
| for (int i = 0; i < resolved.length; i++) { |
| assertEquals("Entry should be on bootpath", IRuntimeClasspathEntry.BOOTSTRAP_CLASSES, resolved[i].getClasspathProperty()); |
| } |
| } |
| |
| /** |
| * Test that a jar added to the bootpath is resolved to be on the bootpath. |
| */ |
| public void testBootpathJarResolution() throws Exception { |
| IResource archive = get14Project().getProject().getFolder("src").getFile("A.jar"); |
| assertTrue("Archive does not exist", archive.exists()); |
| |
| IRuntimeClasspathEntry jarEntry = JavaRuntime.newArchiveRuntimeClasspathEntry(archive.getFullPath()); |
| jarEntry.setClasspathProperty(IRuntimeClasspathEntry.BOOTSTRAP_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(jarEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", archive.getFullPath(), resolved[0].getPath()); |
| assertEquals("Resolved path not correct", archive.getLocation(), new Path(resolved[0].getLocation())); |
| assertEquals("Resolved entry should be on bootpath", IRuntimeClasspathEntry.BOOTSTRAP_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that a folder added to the bootpath is resolved to be on the bootpath. |
| */ |
| public void testBootpathFolderResolution() throws Exception { |
| IResource folder = get14Project().getProject().getFolder("src"); |
| assertTrue("Folder does not exist", folder.exists()); |
| |
| IRuntimeClasspathEntry folderEntry = JavaRuntime.newArchiveRuntimeClasspathEntry(folder.getFullPath()); |
| folderEntry.setClasspathProperty(IRuntimeClasspathEntry.BOOTSTRAP_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(folderEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", folder.getFullPath(), resolved[0].getPath()); |
| assertEquals("Resolved path not correct", folder.getLocation(), new Path(resolved[0].getLocation())); |
| assertEquals("Resolved entry should be on bootpath", IRuntimeClasspathEntry.BOOTSTRAP_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that a project with non-default output locations placed on the bootpath |
| * resolves to entries on the bootpath. |
| */ |
| public void testBootpathProjectNonDefaultOutputLocationsResolution() throws Exception { |
| IJavaProject project = getMultiOutputProject(); |
| |
| IRuntimeClasspathEntry runtimeClasspathEntry = JavaRuntime.newProjectRuntimeClasspathEntry(project); |
| runtimeClasspathEntry.setClasspathProperty(IRuntimeClasspathEntry.BOOTSTRAP_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(runtimeClasspathEntry, project); |
| assertEquals("Should be 3 resolved entries", 3, resolved.length); // two specific entries & default entry |
| for (int i = 0; i < resolved.length; i++) { |
| IRuntimeClasspathEntry entry = resolved[i]; |
| assertEquals("Resolved entry should be on bootpath", IRuntimeClasspathEntry.BOOTSTRAP_CLASSES, entry.getClasspathProperty()); |
| } |
| |
| } |
| |
| // USER CLASSES TESTS |
| |
| /** |
| * Test that a variable added to the user application classpath is resolved to be on |
| * the user application classpath. |
| */ |
| public void testUserClassesVariableResolution() throws Exception { |
| IResource archive = get14Project().getProject().getFolder("src").getFile("A.jar"); |
| assertTrue("Archive does not exist", archive.exists()); |
| String varName = "bootpathVar"; |
| JavaCore.setClasspathVariable(varName, archive.getFullPath(), null); |
| |
| IRuntimeClasspathEntry runtimeClasspathEntry = JavaRuntime.newVariableRuntimeClasspathEntry(new Path(varName)); |
| runtimeClasspathEntry.setClasspathProperty(IRuntimeClasspathEntry.USER_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(runtimeClasspathEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", archive.getFullPath(), resolved[0].getPath()); |
| assertEquals("Resolved path not correct", archive.getLocation(), new Path(resolved[0].getLocation())); |
| assertEquals("Resolved entry should be on user classpath", IRuntimeClasspathEntry.USER_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that an extended variable added to the user classpath is resolved to be |
| * on the user classpath. |
| */ |
| public void testUserClassesVariableExtensionResolution() throws Exception { |
| IResource archive = get14Project().getProject().getFolder("src").getFile("A.jar"); |
| IProject root = get14Project().getProject(); |
| String varName = "bootpathVarRoot"; |
| JavaCore.setClasspathVariable(varName, root.getFullPath(), null); |
| |
| IRuntimeClasspathEntry runtimeClasspathEntry = JavaRuntime.newVariableRuntimeClasspathEntry(new Path(varName).append(new Path("src")).append(new Path("A.jar"))); |
| runtimeClasspathEntry.setClasspathProperty(IRuntimeClasspathEntry.USER_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(runtimeClasspathEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", archive.getFullPath(), resolved[0].getPath()); |
| assertEquals("Resolved path not correct", archive.getLocation(), new Path(resolved[0].getLocation())); |
| assertEquals("Resolved entry should be on user classpath", IRuntimeClasspathEntry.USER_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that a project added to the user classpath is resolved to be on the |
| * user classpath. |
| */ |
| public void testUserClassesProjectResolution() throws Exception { |
| IJavaProject project = get14Project(); |
| IResource outputFolder = ResourcesPlugin.getWorkspace().getRoot().findMember(project.getOutputLocation()); |
| |
| IRuntimeClasspathEntry runtimeClasspathEntry = JavaRuntime.newProjectRuntimeClasspathEntry(project); |
| runtimeClasspathEntry.setClasspathProperty(IRuntimeClasspathEntry.USER_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(runtimeClasspathEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", outputFolder.getLocation().toOSString(), resolved[0].getLocation()); |
| assertEquals("Resolved entry should be on user classpath", IRuntimeClasspathEntry.USER_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that a container added to the user classpath is resolved to have all |
| * entries on the user classpath. |
| */ |
| public void testUserClassesContainerResolution() throws Exception { |
| IRuntimeClasspathEntry entry = JavaRuntime.newRuntimeContainerClasspathEntry(new Path(JavaRuntime.JRE_CONTAINER), IRuntimeClasspathEntry.USER_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(entry, get14Project()); |
| // each resolved entry should be on the bootpath |
| for (int i = 0; i < resolved.length; i++) { |
| assertEquals("Entry should be on user classpath", IRuntimeClasspathEntry.USER_CLASSES, resolved[i].getClasspathProperty()); |
| } |
| } |
| |
| /** |
| * Test that a jar added to the user classpath is resolved to be on the user classpath. |
| */ |
| public void testUserClassesJarResolution() throws Exception { |
| IResource archive = get14Project().getProject().getFolder("src").getFile("A.jar"); |
| assertTrue("Archive does not exist", archive.exists()); |
| |
| IRuntimeClasspathEntry jarEntry = JavaRuntime.newArchiveRuntimeClasspathEntry(archive.getFullPath()); |
| jarEntry.setClasspathProperty(IRuntimeClasspathEntry.USER_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(jarEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", archive.getFullPath(), resolved[0].getPath()); |
| assertEquals("Resolved path not correct", archive.getLocation(), new Path(resolved[0].getLocation())); |
| assertEquals("Resolved entry should be on user classpath", IRuntimeClasspathEntry.USER_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that a folder added to the user classpath is resolved to be on the |
| * user classpath. |
| */ |
| public void testUserClassesFolderResolution() throws Exception { |
| IResource folder = get14Project().getProject().getFolder("src"); |
| assertTrue("Folder does not exist", folder.exists()); |
| |
| IRuntimeClasspathEntry folderEntry = JavaRuntime.newArchiveRuntimeClasspathEntry(folder.getFullPath()); |
| folderEntry.setClasspathProperty(IRuntimeClasspathEntry.USER_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(folderEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", folder.getFullPath(), resolved[0].getPath()); |
| assertEquals("Resolved path not correct", folder.getLocation(), new Path(resolved[0].getLocation())); |
| assertEquals("Resolved entry should be on user classpath", IRuntimeClasspathEntry.USER_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that a project with non-default output locations placed on the user classpath |
| * resolves to entries on the user classpath. |
| */ |
| public void testUserClassesProjectNonDefaultOutputLocationsResolution() throws Exception { |
| IJavaProject project = getMultiOutputProject(); |
| |
| IRuntimeClasspathEntry runtimeClasspathEntry = JavaRuntime.newProjectRuntimeClasspathEntry(project); |
| runtimeClasspathEntry.setClasspathProperty(IRuntimeClasspathEntry.USER_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(runtimeClasspathEntry, project); |
| assertEquals("Should be 3 resolved entries", 3, resolved.length); // two specific entries & default entry |
| for (int i = 0; i < resolved.length; i++) { |
| IRuntimeClasspathEntry entry = resolved[i]; |
| assertEquals("Resolved entry should be on user classpath", IRuntimeClasspathEntry.USER_CLASSES, entry.getClasspathProperty()); |
| } |
| |
| } |
| |
| // STANDARD CLASSES TESTS |
| |
| /** |
| * Test that a variable added to the default bootpath is resolved to be on |
| * the default bootpath. |
| */ |
| public void testStandardClassesVariableResolution() throws Exception { |
| IResource archive = get14Project().getProject().getFolder("src").getFile("A.jar"); |
| assertTrue("Archive does not exist", archive.exists()); |
| String varName = "bootpathVar"; |
| JavaCore.setClasspathVariable(varName, archive.getFullPath(), null); |
| |
| IRuntimeClasspathEntry runtimeClasspathEntry = JavaRuntime.newVariableRuntimeClasspathEntry(new Path(varName)); |
| runtimeClasspathEntry.setClasspathProperty(IRuntimeClasspathEntry.STANDARD_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(runtimeClasspathEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", archive.getFullPath(), resolved[0].getPath()); |
| assertEquals("Resolved path not correct", archive.getLocation(), new Path(resolved[0].getLocation())); |
| assertEquals("Resolved entry should be on default bootpath", IRuntimeClasspathEntry.STANDARD_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that an extended variable added to the default bootpath is resolved to be |
| * on the default bootpath. |
| */ |
| public void testStandardClassesVariableExtensionResolution() throws Exception { |
| IResource archive = get14Project().getProject().getFolder("src").getFile("A.jar"); |
| IProject root = get14Project().getProject(); |
| String varName = "bootpathVarRoot"; |
| JavaCore.setClasspathVariable(varName, root.getFullPath(), null); |
| |
| IRuntimeClasspathEntry runtimeClasspathEntry = JavaRuntime.newVariableRuntimeClasspathEntry(new Path(varName).append(new Path("src")).append(new Path("A.jar"))); |
| runtimeClasspathEntry.setClasspathProperty(IRuntimeClasspathEntry.STANDARD_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(runtimeClasspathEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", archive.getFullPath(), resolved[0].getPath()); |
| assertEquals("Resolved path not correct", archive.getLocation(), new Path(resolved[0].getLocation())); |
| assertEquals("Resolved entry should be on default bootpath", IRuntimeClasspathEntry.STANDARD_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that a project added to the default bootpath is resolved to be on the |
| * default bootpath. |
| */ |
| public void testStandardClassesProjectResolution() throws Exception { |
| IJavaProject project = get14Project(); |
| IResource outputFolder = ResourcesPlugin.getWorkspace().getRoot().findMember(project.getOutputLocation()); |
| |
| IRuntimeClasspathEntry runtimeClasspathEntry = JavaRuntime.newProjectRuntimeClasspathEntry(project); |
| runtimeClasspathEntry.setClasspathProperty(IRuntimeClasspathEntry.STANDARD_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(runtimeClasspathEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", outputFolder.getLocation().toOSString(), resolved[0].getLocation()); |
| assertEquals("Resolved entry should be on default bootpath", IRuntimeClasspathEntry.STANDARD_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that a container added to the default bootpath is resolved to have all |
| * entries on the default bootpath. |
| */ |
| public void testStandardClassesContainerResolution() throws Exception { |
| IRuntimeClasspathEntry entry = JavaRuntime.newRuntimeContainerClasspathEntry(new Path(JavaRuntime.JRE_CONTAINER), IRuntimeClasspathEntry.STANDARD_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(entry, get14Project()); |
| // each resolved entry should be on the bootpath |
| for (int i = 0; i < resolved.length; i++) { |
| assertEquals("Entry should be on default bootpath", IRuntimeClasspathEntry.STANDARD_CLASSES, resolved[i].getClasspathProperty()); |
| } |
| } |
| |
| /** |
| * Test that a jar added to the default bootpath is resolved to be on the |
| * default bootpath. |
| */ |
| public void testStandardClassesJarResolution() throws Exception { |
| IResource archive = get14Project().getProject().getFolder("src").getFile("A.jar"); |
| assertTrue("Archive does not exist", archive.exists()); |
| |
| IRuntimeClasspathEntry jarEntry = JavaRuntime.newArchiveRuntimeClasspathEntry(archive.getFullPath()); |
| jarEntry.setClasspathProperty(IRuntimeClasspathEntry.STANDARD_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(jarEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", archive.getFullPath(), resolved[0].getPath()); |
| assertEquals("Resolved path not correct", archive.getLocation(), new Path(resolved[0].getLocation())); |
| assertEquals("Resolved entry should be on default bootpath", IRuntimeClasspathEntry.STANDARD_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that a folder added to the default bootpath is resolved to be on the |
| * default bootpath. |
| */ |
| public void testStandardClassesFolderResolution() throws Exception { |
| IResource folder = get14Project().getProject().getFolder("src"); |
| assertTrue("Folder does not exist", folder.exists()); |
| |
| IRuntimeClasspathEntry folderEntry = JavaRuntime.newArchiveRuntimeClasspathEntry(folder.getFullPath()); |
| folderEntry.setClasspathProperty(IRuntimeClasspathEntry.STANDARD_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(folderEntry, get14Project()); |
| assertEquals("Should be one resolved entry", 1, resolved.length); |
| assertEquals("Resolved path not correct", folder.getFullPath(), resolved[0].getPath()); |
| assertEquals("Resolved path not correct", folder.getLocation(), new Path(resolved[0].getLocation())); |
| assertEquals("Resolved entry should be on default bootpath", IRuntimeClasspathEntry.STANDARD_CLASSES, resolved[0].getClasspathProperty()); |
| } |
| |
| /** |
| * Test that a project with non-default output locations placed on the default bootpath |
| * resolves to entries on the default bootpath. |
| */ |
| public void testStandardClassesProjectNonDefaultOutputLocationsResolution() throws Exception { |
| IJavaProject project = getMultiOutputProject(); |
| |
| IRuntimeClasspathEntry runtimeClasspathEntry = JavaRuntime.newProjectRuntimeClasspathEntry(project); |
| runtimeClasspathEntry.setClasspathProperty(IRuntimeClasspathEntry.STANDARD_CLASSES); |
| IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(runtimeClasspathEntry, project); |
| assertEquals("Should be 3 resolved entries", 3, resolved.length); // two specific entries & default entry |
| for (int i = 0; i < resolved.length; i++) { |
| IRuntimeClasspathEntry entry = resolved[i]; |
| assertEquals("Resolved entry should be on default bootpath", IRuntimeClasspathEntry.STANDARD_CLASSES, entry.getClasspathProperty()); |
| } |
| |
| } |
| |
| /** |
| * Tests that default classpath computation works for a project with mulitple |
| * output locations. |
| * |
| * @throws Exception |
| */ |
| public void testMultiOutputDefaultClasspath() throws Exception { |
| IJavaProject project = getMultiOutputProject(); |
| String[] entries = JavaRuntime.computeDefaultRuntimeClassPath(project); |
| IProject p = project.getProject(); |
| IFolder bin1 = p.getFolder("bin1"); |
| IFolder bin2 = p.getFolder("bin2"); |
| String location1 = bin1.getLocation().toOSString(); |
| String location2 = bin2.getLocation().toOSString(); |
| |
| List<String> list = new ArrayList<String>(); |
| for (int i = 0; i < entries.length; i++) { |
| list.add(entries[i]); |
| } |
| |
| assertTrue("Classpath is missing " + location1, list.contains(location1)); |
| assertTrue("Classpath is missing " + location2, list.contains(location2)); |
| |
| } |
| |
| /** |
| * Tests that default classpath computation works for a project with a default |
| * output location. |
| * |
| * @throws Exception |
| */ |
| public void testSingleOutputDefaultClasspath() throws Exception { |
| IJavaProject project = get14Project(); |
| String[] entries = JavaRuntime.computeDefaultRuntimeClassPath(project); |
| |
| IFolder bin = ResourcesPlugin.getWorkspace().getRoot().getFolder(project.getOutputLocation()); |
| String location = bin.getLocation().toOSString(); |
| |
| List<String> list = new ArrayList<String>(); |
| for (int i = 0; i < entries.length; i++) { |
| list.add(entries[i]); |
| } |
| |
| assertTrue("Classpath is missing " + location, list.contains(location)); |
| |
| } |
| |
| /** |
| * Tests that a buildpath with a relative (../..) classpath entry will resolve properly. |
| * |
| * @throws Exception |
| */ |
| public void testRelativeClasspathEntry() throws Exception { |
| // create a project with a relative classpath entry |
| IProject pro = ResourcesPlugin.getWorkspace().getRoot().getProject("RelativeCP"); |
| assertFalse("Project should not exist", pro.exists()); |
| |
| // create project with source folder and output location |
| IJavaProject project = JavaProjectHelper.createJavaProject("RelativeCP"); |
| JavaProjectHelper.addSourceContainer(project, "src", "bin"); |
| IExecutionEnvironment j2se14 = JavaRuntime.getExecutionEnvironmentsManager().getEnvironment("J2SE-1.4"); |
| assertNotNull("Missing J2SE-1.4 environment", j2se14); |
| IPath path = JavaRuntime.newJREContainerPath(j2se14); |
| JavaProjectHelper.addContainerEntry(project, path); |
| // add relative entry - point to A.jar in DebugTests/src |
| JavaProjectHelper.addLibrary(project, new Path("../DebugTests/src/A.jar")); |
| |
| // test runtime class path resolution |
| String[] entries = JavaRuntime.computeDefaultRuntimeClassPath(project); |
| String jarPath = get14Project().getProject().getLocation().append("src").append("A.jar").toOSString(); |
| List<String> list = new ArrayList<String>(); |
| for (int i = 0; i < entries.length; i++) { |
| list.add(entries[i]); |
| } |
| |
| // delete the project |
| pro.delete(false, null); |
| |
| assertTrue("Classpath is missing " + jarPath, list.contains(jarPath)); |
| } |
| |
| /** |
| * Tests that a variable with a relative (../..) path will resolve properly. |
| * |
| * @throws Exception |
| */ |
| public void testVariableWithRelativePath() throws Exception { |
| // create a project with a relative classpath entry |
| IProject pro = ResourcesPlugin.getWorkspace().getRoot().getProject("RelativeVar"); |
| assertFalse("Project should not exist", pro.exists()); |
| |
| // create project with source folder and output location |
| IJavaProject project = JavaProjectHelper.createJavaProject("RelativeVar"); |
| JavaProjectHelper.addSourceContainer(project, "src", "bin"); |
| IExecutionEnvironment j2se14 = JavaRuntime.getExecutionEnvironmentsManager().getEnvironment("J2SE-1.4"); |
| assertNotNull("Missing J2SE-1.4 environment", j2se14); |
| IPath path = JavaRuntime.newJREContainerPath(j2se14); |
| JavaProjectHelper.addContainerEntry(project, path); |
| // add relative entry - point to A.jar in DebugTests/src |
| String varName = "RELATIVE_DEBUG_TESTS"; |
| JavaCore.setClasspathVariable(varName, new Path("../DebugTests"), null); |
| JavaProjectHelper.addVariableEntry(project, new Path("RELATIVE_DEBUG_TESTS/src/A.jar"), null, null); |
| |
| // test runtime class path resolution |
| String[] entries = JavaRuntime.computeDefaultRuntimeClassPath(project); |
| String jarPath = get14Project().getProject().getLocation().append("src").append("A.jar").toOSString(); |
| List<String> list = new ArrayList<String>(); |
| for (int i = 0; i < entries.length; i++) { |
| list.add(entries[i]); |
| } |
| |
| // delete the project |
| pro.delete(false, null); |
| |
| assertTrue("Classpath is missing " + jarPath, list.contains(jarPath)); |
| } |
| } |