Attachment #160356 for bug #281551




/*******************************************************************************
 * Copyright (c) 2000, 2010 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

	 */
	IPath getSourceAttachmentRootPath();

	
	/**
	 * Returns the classpath entry that is making a reference to this classpath entry. For entry kinds 
	 * {@link #CPE_LIBRARY}, the return value is the entry that is representing the JAR that includes 
	 * <code>this</code> in the MANIFEST.MF file's Class-Path section. For entry kinds other than 
	 * {@link #CPE_LIBRARY}, this returns null. For those entries that are on the raw classpath already, 
	 * this returns <code>null</code>  
	 * <p>
	 * It is possible that multiple library entries refer to the same entry
	 * via the MANIFEST.MF file. In those cases, this method returns the first classpath entry 
	 * that appears in the raw classpath. However, this does not mean that the other referencing 
	 * entries do not relate to their referenced entries. 
	 * See {@link JavaCore#getReferencedClasspathEntries(IClasspathEntry, IJavaProject)} for 
	 * more details.
	 * </p>
	 * 
	 * @return the classpath entry that is referencing this entry or <code>null</code> if 
	 * 		not applicable.
	 * @since 3.6
	 */
	IClasspathEntry getReferencingEntry();

	/**
	 * Returns whether this entry is exported to dependent projects.
	 * Always returns <code>false</code> for source entries (kind




/*******************************************************************************
 * Copyright (c) 2000, 2010 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

	void setRawClasspath(IClasspathEntry[] entries, boolean canModifyResources, IProgressMonitor monitor) throws JavaModelException;

	/**
	 * Works same as {@link #setRawClasspath(IClasspathEntry[], IPath, IProgressMonitor)} and 
	 * additionally allows persisting the given array of referenced entries for this project.
	 * The referenced entries and their attributes are stores in the .classpath file of this 
	 * project. For details on  referenced entries, see 
	 * {@link JavaCore#getReferencedClasspathEntries(IClasspathEntry, IJavaProject)}
	 * and {@link IClasspathEntry#getReferencingEntry()}.
	 * <p>
	 * Since the referenced entries are stored in the .classpath file, clients can store additional 
	 * information that belong to these entries and retrieve them across sessions, though the referenced
	 * entries themselves may not be present in the raw classpath. By passing a <code>null</code>
	 * referencedEntries, clients can choose not to modify the already persisted referenced entries,
	 * which is fully equivalent to {@link #setRawClasspath(IClasspathEntry[], IPath, IProgressMonitor)}.
	 * If an empty array is passed as referencedEntries, the already persisted referenced entries, 
	 * if any, will be cleared. 
	 * </p> <p>
	 * If there are duplicates of a referenced entry or if any of the <code>referencedEntries</code> 
	 * is already present in the raw classpath(<code>entries</code>) those referenced entries will 
	 * be excluded and will not be persisted.
	 *</p>
	 * @param entries a list of classpath entries
	 * @param referencedEntries the list of referenced classpath entries to be persisted
	 * @param outputLocation the default output location
	 * @param monitor the given progress monitor
	 * @exception JavaModelException if the classpath could not be set. Reasons include:
	 * <ul>
	 * <li> This Java element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
	 * <li> The classpath is being modified during resource change event notification (CORE_EXCEPTION)
	 * <li> The classpath failed the validation check as defined by {@link JavaConventions#validateClasspath(IJavaProject, IClasspathEntry[], IPath)}
	 * </ul>
	 * @see IClasspathEntry
	 * @see #getReferencedClasspathEntries()
	 * @since 3.6
	 */
	void setRawClasspath(IClasspathEntry[] entries, IClasspathEntry[] referencedEntries, IPath outputLocation,
			IProgressMonitor monitor) throws JavaModelException;

	/**
	 * Returns the list of referenced classpath entries stored in the .classpath file of <code>this</code> 
	 * java project. Clients can store the referenced classpath entries using 
	 * {@link #setRawClasspath(IClasspathEntry[], IClasspathEntry[], IPath, IProgressMonitor)}
	 * 
	 * @throws JavaModelException
	 * @return an array of referenced classpath entries stored for this java project
	 * @since 3.6
	 */
	IClasspathEntry[] getReferencedClasspathEntries() throws JavaModelException;
	
	/**
	 * Sets the classpath of this project using a list of classpath entries. In particular such a classpath may contain
	 * classpath variable entries. Classpath variable entries can be resolved individually ({@link JavaCore#getClasspathVariable(String)}),
	 * or the full classpath can be resolved at once using the helper method {@link #getResolvedClasspath(boolean)}.




/*******************************************************************************
 * Copyright (c) 2000, 2010 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

	 * @since 2.0
	 */
	IClasspathEntry getRawClasspathEntry() throws JavaModelException;
	
	/**
	 * Returns the first resolved classpath entry that corresponds to this package fragment root.
	 * A resolved classpath entry is said to correspond to a root if the path of the resolved
	 * entry is equal to the root's path.
	 * 
	 * @return the first resolved classpath entry that corresponds to this package fragment root
	 * @throws JavaModelException if this element does not exist or if an
	 *		exception occurs while accessing its corresponding resource. 
	 * @since 3.6
	 */
	IClasspathEntry getResolvedClasspathEntry() throws JavaModelException;

	/**
	 * Returns the absolute path to the source archive attached to




			false, // no access rules to combine
			extraAttributes);
	}
	
	/**
	 * Returns an array of classpath entries that are referenced directly or indirectly 
	 * by a given classpath entry. For the entry kind {@link IClasspathEntry#CPE_LIBRARY}, 
	 * the method returns the libraries that are included in the Class-Path section of 
	 * the MANIFEST.MF file. If a referenced JAR file has further references to other library 
	 * entries, they are processed recursively and added to the list. For entry kinds other 
	 * than {@link IClasspathEntry#CPE_LIBRARY}, this method returns an empty array.
	 * <p> 
	 * If a referenced entry has already been stored 
	 * in the given project's .classpath, the stored attributes are populated in the corresponding
	 * referenced entry. For more details on storing referenced entries see
	 * see {@link IJavaProject#setRawClasspath(IClasspathEntry[], IClasspathEntry[], IPath, 
	 * IProgressMonitor)}. 
	 * </p>
	 * 
	 * @param libraryEntry the library entry whose referenced entries are sought 
	 * @param project project where the persisted referenced entries to be retrieved from
	 * @return an array of classpath entries that are referenced directly or indirectly by the given entry. 
	 * 			If not applicable, returns an emptry array.
	 * @since 3.6
	 */
	public static IClasspathEntry[] getReferencedClasspathEntries(IClasspathEntry libraryEntry, IJavaProject project) {
		JavaModelManager manager = JavaModelManager.getJavaModelManager();
		return manager.getReferencedClasspathEntries(libraryEntry, project);
	}
	
	/**
	 * Removed the given classpath variable. Does nothing if no value was
	 * set for this classpath variable.

Lines 77-82 Link Here

(-)model/org/eclipse/jdt/internal/core/ClasspathEntry.java (-20 / +68 lines)
77		77
78	public static final String TAG_CLASSPATH = "classpath"; //$NON-NLS-1$	78	public static final String TAG_CLASSPATH = "classpath"; //$NON-NLS-1$
79	public static final String TAG_CLASSPATHENTRY = "classpathentry"; //$NON-NLS-1$	79	public static final String TAG_CLASSPATHENTRY = "classpathentry"; //$NON-NLS-1$
		80	public static final String TAG_REFERENCED_ENTRY = "referencedentry"; //$NON-NLS-1$
80	public static final String TAG_OUTPUT = "output"; //$NON-NLS-1$	81	public static final String TAG_OUTPUT = "output"; //$NON-NLS-1$
81	public static final String TAG_KIND = "kind"; //$NON-NLS-1$	82	public static final String TAG_KIND = "kind"; //$NON-NLS-1$
82	public static final String TAG_PATH = "path"; //$NON-NLS-1$	83	public static final String TAG_PATH = "path"; //$NON-NLS-1$
Lines 141-147 Link Here
141	private IPath[] exclusionPatterns;	142	private IPath[] exclusionPatterns;
142	private char[][] fullExclusionPatternChars;	143	private char[][] fullExclusionPatternChars;
143	private final static char[][] UNINIT_PATTERNS = new char[][] { "Non-initialized yet".toCharArray() }; //$NON-NLS-1$	144	private final static char[][] UNINIT_PATTERNS = new char[][] { "Non-initialized yet".toCharArray() }; //$NON-NLS-1$
144	private final static ClasspathEntry[] NO_ENTRIES = new ClasspathEntry[0];	145	public final static ClasspathEntry[] NO_ENTRIES = new ClasspathEntry[0];
145	private final static IPath[] NO_PATHS = new IPath[0];	146	private final static IPath[] NO_PATHS = new IPath[0];
146	private final static IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();	147	private final static IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
147		148
Lines 197-202 Link Here
197	* a non-<code>null</code> value.	198	* a non-<code>null</code> value.
198	*/	199	*/
199	public IPath sourceAttachmentRootPath;	200	public IPath sourceAttachmentRootPath;
		201
		202	/**
		203	* See {@link IClasspathEntry#getReferencingEntry()}
		204	*/
		205	public IClasspathEntry referencingEntry;
200		206
201	/**	207	/**
202	* Specific output location (for this source entry)	208	* Specific output location (for this source entry)
Lines 215-225 Link Here
215	*/	221	*/
216	public boolean isExported;	222	public boolean isExported;
217		223
218	/*	224	/**
219	* The extra attributes	225	* The extra attributes
220	*/	226	*/
221	IClasspathAttribute[] extraAttributes;	227	public IClasspathAttribute[] extraAttributes;
222		228
		229	public ClasspathEntry(
		230	int contentKind,
		231	int entryKind,
		232	IPath path,
		233	IPath[] inclusionPatterns,
		234	IPath[] exclusionPatterns,
		235	IPath sourceAttachmentPath,
		236	IPath sourceAttachmentRootPath,
		237	IPath specificOutputLocation,
		238	boolean isExported,
		239	IAccessRule[] accessRules,
		240	boolean combineAccessRules,
		241	IClasspathAttribute[] extraAttributes) {
		242
		243	this( contentKind,
		244	entryKind,
		245	path,
		246	inclusionPatterns,
		247	exclusionPatterns,
		248	sourceAttachmentPath,
		249	sourceAttachmentRootPath,
		250	specificOutputLocation,
		251	null,
		252	isExported,
		253	accessRules,
		254	combineAccessRules,
		255	extraAttributes);
		256	}
		257
223	/**	258	/**
224	* Creates a class path entry of the specified kind with the given path.	259	* Creates a class path entry of the specified kind with the given path.
225	*/	260	*/
Lines 232-237 Link Here
232	IPath sourceAttachmentPath,	267	IPath sourceAttachmentPath,
233	IPath sourceAttachmentRootPath,	268	IPath sourceAttachmentRootPath,
234	IPath specificOutputLocation,	269	IPath specificOutputLocation,
		270	IClasspathEntry referencingEntry,
235	boolean isExported,	271	boolean isExported,
236	IAccessRule[] accessRules,	272	IAccessRule[] accessRules,
237	boolean combineAccessRules,	273	boolean combineAccessRules,
Lines 242-248 Link Here
242	this.path = path;	278	this.path = path;
243	this.inclusionPatterns = inclusionPatterns;	279	this.inclusionPatterns = inclusionPatterns;
244	this.exclusionPatterns = exclusionPatterns;	280	this.exclusionPatterns = exclusionPatterns;
245		281	this.referencingEntry = referencingEntry;
		282
246	int length;	283	int length;
247	if (accessRules != null && (length = accessRules.length) > 0) {	284	if (accessRules != null && (length = accessRules.length) > 0) {
248	AccessRule[] rules = new AccessRule[length];	285	AccessRule[] rules = new AccessRule[length];
Lines 489-495 Link Here
489	/**	526	/**
490	* Returns the XML encoding of the class path.	527	* Returns the XML encoding of the class path.
491	*/	528	*/
492	public void elementEncode(XMLWriter writer, IPath projectPath, boolean indent, boolean newLine, Map unknownElements) {	529	public void elementEncode(XMLWriter writer, IPath projectPath, boolean indent, boolean newLine, Map unknownElements, boolean isReferencedEntry) {
493	HashMap parameters = new HashMap();	530	HashMap parameters = new HashMap();
494		531
495	parameters.put(TAG_KIND, ClasspathEntry.kindToString(this.entryKind));	532	parameters.put(TAG_KIND, ClasspathEntry.kindToString(this.entryKind));
Lines 553-564 Link Here
553	boolean hasRestrictions = getAccessRuleSet() != null; // access rule set is null if no access rules	590	boolean hasRestrictions = getAccessRuleSet() != null; // access rule set is null if no access rules
554	ArrayList unknownChildren = unknownXmlElements != null ? unknownXmlElements.children : null;	591	ArrayList unknownChildren = unknownXmlElements != null ? unknownXmlElements.children : null;
555	boolean hasUnknownChildren = unknownChildren != null;	592	boolean hasUnknownChildren = unknownChildren != null;
		593
		594	/* close tag if no extra attributes, no restriction and no unknown children */
		595	String tagName = isReferencedEntry ? TAG_REFERENCED_ENTRY : TAG_CLASSPATHENTRY;
556	writer.printTag(	596	writer.printTag(
557	TAG_CLASSPATHENTRY,	597	tagName,
558	parameters,	598	parameters,
559	indent,	599	indent,
560	newLine,	600	newLine,
561	!hasExtraAttributes && !hasRestrictions && !hasUnknownChildren/close tag if no extra attributes, no restriction and no unknown children/);	601	!hasExtraAttributes && !hasRestrictions && !hasUnknownChildren);
562		602
563	if (hasExtraAttributes)	603	if (hasExtraAttributes)
564	encodeExtraAttributes(writer, indent, newLine);	604	encodeExtraAttributes(writer, indent, newLine);
Lines 570-576 Link Here
570	encodeUnknownChildren(writer, indent, newLine, unknownChildren);	610	encodeUnknownChildren(writer, indent, newLine, unknownChildren);
571		611
572	if (hasExtraAttributes \|\| hasRestrictions \|\| hasUnknownChildren)	612	if (hasExtraAttributes \|\| hasRestrictions \|\| hasUnknownChildren)
573	writer.endTag(TAG_CLASSPATHENTRY, indent, true/insert new line/);	613	writer.endTag(tagName, indent, true/insert new line/);
574	}	614	}
575		615
576	void encodeExtraAttributes(XMLWriter writer, boolean indent, boolean newLine) {	616	void encodeExtraAttributes(XMLWriter writer, boolean indent, boolean newLine) {
Lines 1178-1183 Link Here
1178	return this.sourceAttachmentRootPath;	1218	return this.sourceAttachmentRootPath;
1179	}	1219	}
1180		1220
		1221
		1222	public IClasspathEntry getReferencingEntry() {
		1223	return this.referencingEntry;
		1224	}
		1225
1181	/**	1226	/**
1182	* Returns the hash code for this classpath entry	1227	* Returns the hash code for this classpath entry
1183	*/	1228	*/
Lines 1380-1385 Link Here
1380	getSourceAttachmentPath(),	1425	getSourceAttachmentPath(),
1381	getSourceAttachmentRootPath(),	1426	getSourceAttachmentRootPath(),
1382	getOutputLocation(),	1427	getOutputLocation(),
		1428	this.getReferencingEntry(),
1383	this.isExported,	1429	this.isExported,
1384	getAccessRules(),	1430	getAccessRules(),
1385	this.combineAccessRules,	1431	this.combineAccessRules,
Lines 1397-1415 Link Here
1397	return NO_ENTRIES;	1443	return NO_ENTRIES;
1398	ClasspathEntry[] result = new ClasspathEntry[length];	1444	ClasspathEntry[] result = new ClasspathEntry[length];
1399	for (int i = 0; i < length; i++) {	1445	for (int i = 0; i < length; i++) {
		1446	// Chained(referenced) libraries can have their own attachment path. Hence, set them to null
1400	result[i] = new ClasspathEntry(	1447	result[i] = new ClasspathEntry(
1401	getContentKind(),	1448	getContentKind(),
1402	getEntryKind(),	1449	getEntryKind(),
1403	paths[i],	1450	paths[i],
1404	this.inclusionPatterns,	1451	this.inclusionPatterns,
1405	this.exclusionPatterns,	1452	this.exclusionPatterns,
1406	getSourceAttachmentPath(),	1453	null,
1407	getSourceAttachmentRootPath(),	1454	null,
1408	getOutputLocation(),	1455	getOutputLocation(),
1409	this.isExported,	1456	this,
1410	getAccessRules(),	1457	this.isExported,
1411	this.combineAccessRules,	1458	getAccessRules(),
1412	this.extraAttributes);	1459	this.combineAccessRules,
		1460	NO_EXTRA_ATTRIBUTES);
1413	}	1461	}
1414	return result;	1462	return result;
1415	}	1463	}

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaModelManager.java (-21 / +68 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 1095-1100 Link Here
1095	public Object savedState;	1095	public Object savedState;
1096	public boolean triedRead;	1096	public boolean triedRead;
1097	public IClasspathEntry[] rawClasspath;	1097	public IClasspathEntry[] rawClasspath;
		1098	public IClasspathEntry[] referencedEntries;
1098	public IJavaModelStatus rawClasspathStatus;	1099	public IJavaModelStatus rawClasspathStatus;
1099	public int rawTimeStamp = 0;	1100	public int rawTimeStamp = 0;
1100	public boolean writtingRawClasspath = false;	1101	public boolean writtingRawClasspath = false;
Lines 1169-1177 Link Here
1169	return setResolvedClasspath(null, null, null, null, this.rawTimeStamp, true/add classpath change/);	1170	return setResolvedClasspath(null, null, null, null, this.rawTimeStamp, true/add classpath change/);
1170	}	1171	}
1171		1172
1172	private ClasspathChange setClasspath(IClasspathEntry[] newRawClasspath, IPath newOutputLocation, IJavaModelStatus newRawClasspathStatus, IClasspathEntry[] newResolvedClasspath, Map newRootPathToRawEntries, Map newRootPathToResolvedEntries, IJavaModelStatus newUnresolvedEntryStatus, boolean addClasspathChange) {	1173	private ClasspathChange setClasspath(IClasspathEntry[] newRawClasspath, IClasspathEntry[] referencedEntries, IPath newOutputLocation, IJavaModelStatus newRawClasspathStatus, IClasspathEntry[] newResolvedClasspath, Map newRootPathToRawEntries, Map newRootPathToResolvedEntries, IJavaModelStatus newUnresolvedEntryStatus, boolean addClasspathChange) {
1173	ClasspathChange classpathChange = addClasspathChange ? addClasspathChange() : null;	1174	ClasspathChange classpathChange = addClasspathChange ? addClasspathChange() : null;
1174		1175
		1176	if (referencedEntries != null) this.referencedEntries = referencedEntries;
		1177	if (this.referencedEntries == null) this.referencedEntries = ClasspathEntry.NO_ENTRIES;
1175	this.rawClasspath = newRawClasspath;	1178	this.rawClasspath = newRawClasspath;
1176	this.outputLocation = newOutputLocation;	1179	this.outputLocation = newOutputLocation;
1177	this.rawClasspathStatus = newRawClasspathStatus;	1180	this.rawClasspathStatus = newRawClasspathStatus;
Lines 1191-1222 Link Here
1191	return classpathChange;	1194	return classpathChange;
1192	}	1195	}
1193		1196
1194	public synchronized ClasspathChange setRawClasspath(IClasspathEntry[] newRawClasspath, IPath newOutputLocation, IJavaModelStatus newRawClasspathStatus) {	1197	public ClasspathChange setRawClasspath(IClasspathEntry[] newRawClasspath, IPath newOutputLocation, IJavaModelStatus newRawClasspathStatus) {
		1198	return setRawClasspath(newRawClasspath, null, newOutputLocation, newRawClasspathStatus);
		1199	}
		1200
		1201	public synchronized ClasspathChange setRawClasspath(IClasspathEntry[] newRawClasspath, IClasspathEntry[] referencedEntries, IPath newOutputLocation, IJavaModelStatus newRawClasspathStatus) {
1195	this.rawTimeStamp++;	1202	this.rawTimeStamp++;
1196	return setClasspath(newRawClasspath, newOutputLocation, newRawClasspathStatus, null/resolved classpath/, null/root to raw map/, null/root to resolved map/, null/unresolved status/, true/add classpath change/);	1203	return setClasspath(newRawClasspath, referencedEntries, newOutputLocation, newRawClasspathStatus, null/resolved classpath/, null/root to raw map/, null/root to resolved map/, null/unresolved status/, true/add classpath change/);
1197	}	1204	}
1198		1205
1199	public synchronized ClasspathChange setResolvedClasspath(IClasspathEntry[] newResolvedClasspath, Map newRootPathToRawEntries, Map newRootPathToResolvedEntries, IJavaModelStatus newUnresolvedEntryStatus, int timeStamp, boolean addClasspathChange) {	1206	public ClasspathChange setResolvedClasspath(IClasspathEntry[] newResolvedClasspath, Map newRootPathToRawEntries, Map newRootPathToResolvedEntries, IJavaModelStatus newUnresolvedEntryStatus, int timeStamp, boolean addClasspathChange) {
		1207	return setResolvedClasspath(newResolvedClasspath, null, newRootPathToRawEntries, newRootPathToResolvedEntries, newUnresolvedEntryStatus, timeStamp, addClasspathChange);
		1208	}
		1209
		1210	public synchronized ClasspathChange setResolvedClasspath(IClasspathEntry[] newResolvedClasspath, IClasspathEntry[] referencedEntries, Map newRootPathToRawEntries, Map newRootPathToResolvedEntries, IJavaModelStatus newUnresolvedEntryStatus, int timeStamp, boolean addClasspathChange) {
1200	if (this.rawTimeStamp != timeStamp)	1211	if (this.rawTimeStamp != timeStamp)
1201	return null;	1212	return null;
1202	return setClasspath(this.rawClasspath, this.outputLocation, this.rawClasspathStatus, newResolvedClasspath, newRootPathToRawEntries, newRootPathToResolvedEntries, newUnresolvedEntryStatus, addClasspathChange);	1213	return setClasspath(this.rawClasspath, referencedEntries, this.outputLocation, this.rawClasspathStatus, newResolvedClasspath, newRootPathToRawEntries, newRootPathToResolvedEntries, newUnresolvedEntryStatus, addClasspathChange);
1203	}	1214	}
1204		1215
1205	public synchronized IClasspathEntry[] readAndCacheClasspath(JavaProject javaProject) {	1216	public synchronized IClasspathEntry[][] readAndCacheClasspath(JavaProject javaProject) {
1206	// read file entries and update status	1217	// read file entries and update status
1207	IClasspathEntry[] classpath;	1218	IClasspathEntry[][] classpath;
1208	IJavaModelStatus status;	1219	IJavaModelStatus status;
1209	try {	1220	try {
1210	classpath = javaProject.readFileEntriesWithException(null/not interested in unknown elements/);	1221	classpath = javaProject.readFileEntriesWithException(null/not interested in unknown elements/);
1211	status = JavaModelStatus.VERIFIED_OK;	1222	status = JavaModelStatus.VERIFIED_OK;
1212	} catch (CoreException e) {	1223	} catch (CoreException e) {
1213	classpath = JavaProject.INVALID_CLASSPATH;	1224	classpath = new IClasspathEntry[][]{JavaProject.INVALID_CLASSPATH, ClasspathEntry.NO_ENTRIES};
1214	status =	1225	status =
1215	new JavaModelStatus(	1226	new JavaModelStatus(
1216	IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT,	1227	IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT,
1217	Messages.bind(Messages.classpath_cannotReadClasspathFile, javaProject.getElementName()));	1228	Messages.bind(Messages.classpath_cannotReadClasspathFile, javaProject.getElementName()));
1218	} catch (IOException e) {	1229	} catch (IOException e) {
1219	classpath = JavaProject.INVALID_CLASSPATH;	1230	classpath = new IClasspathEntry[][]{JavaProject.INVALID_CLASSPATH, ClasspathEntry.NO_ENTRIES};
1220	if (Messages.file_badFormat.equals(e.getMessage()))	1231	if (Messages.file_badFormat.equals(e.getMessage()))
1221	status =	1232	status =
1222	new JavaModelStatus(	1233	new JavaModelStatus(
Lines 1228-1234 Link Here
1228	IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT,	1239	IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT,
1229	Messages.bind(Messages.classpath_cannotReadClasspathFile, javaProject.getElementName()));	1240	Messages.bind(Messages.classpath_cannotReadClasspathFile, javaProject.getElementName()));
1230	} catch (ClasspathEntry.AssertionFailedException e) {	1241	} catch (ClasspathEntry.AssertionFailedException e) {
1231	classpath = JavaProject.INVALID_CLASSPATH;	1242	classpath = new IClasspathEntry[][]{JavaProject.INVALID_CLASSPATH, ClasspathEntry.NO_ENTRIES};
1232	status =	1243	status =
1233	new JavaModelStatus(	1244	new JavaModelStatus(
1234	IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT,	1245	IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT,
Lines 1236-1254 Link Here
1236	}	1247	}
1237		1248
1238	// extract out the output location	1249	// extract out the output location
		1250	int rawClasspathLength = classpath[0].length;
1239	IPath output = null;	1251	IPath output = null;
1240	if (classpath.length > 0) {	1252	if (rawClasspathLength > 0) {
1241	IClasspathEntry entry = classpath[classpath.length - 1];	1253	IClasspathEntry entry = classpath[0][rawClasspathLength - 1];
1242	if (entry.getContentKind() == ClasspathEntry.K_OUTPUT) {	1254	if (entry.getContentKind() == ClasspathEntry.K_OUTPUT) {
1243	output = entry.getPath();	1255	output = entry.getPath();
1244	IClasspathEntry[] copy = new IClasspathEntry[classpath.length - 1];	1256	IClasspathEntry[] copy = new IClasspathEntry[rawClasspathLength - 1];
1245	System.arraycopy(classpath, 0, copy, 0, copy.length);	1257	System.arraycopy(classpath[0], 0, copy, 0, copy.length);
1246	classpath = copy;	1258	classpath[0] = copy;
1247	}	1259	}
1248	}	1260	}
1249		1261
1250	// store new raw classpath, new output and new status, and null out resolved info	1262	// store new raw classpath, new output and new status, and null out resolved info
1251	setRawClasspath(classpath, output, status);	1263	setRawClasspath(classpath[0], classpath[1], output, status);
1252		1264
1253	return classpath;	1265	return classpath;
1254	}	1266	}
Lines 1292-1311 Link Here
1292	return buffer.toString();	1304	return buffer.toString();
1293	}	1305	}
1294		1306
1295	public boolean writeAndCacheClasspath(JavaProject javaProject, final IClasspathEntry[] newRawClasspath, final IPath newOutputLocation) throws JavaModelException {	1307	public boolean writeAndCacheClasspath(
		1308	JavaProject javaProject,
		1309	final IClasspathEntry[] newRawClasspath,
		1310	IClasspathEntry[] newReferencedEntries,
		1311	final IPath newOutputLocation) throws JavaModelException {
1296	try {	1312	try {
1297	this.writtingRawClasspath = true;	1313	this.writtingRawClasspath = true;
		1314	if (newReferencedEntries == null) newReferencedEntries = this.referencedEntries;
		1315
1298	// write .classpath	1316	// write .classpath
1299	if (!javaProject.writeFileEntries(newRawClasspath, newOutputLocation)) {	1317	if (!javaProject.writeFileEntries(newRawClasspath, newReferencedEntries, newOutputLocation)) {
1300	return false;	1318	return false;
1301	}	1319	}
1302	// store new raw classpath, new output and new status, and null out resolved info	1320	// store new raw classpath, new output and new status, and null out resolved info
1303	setRawClasspath(newRawClasspath, newOutputLocation, JavaModelStatus.VERIFIED_OK);	1321	setRawClasspath(newRawClasspath, newReferencedEntries, newOutputLocation, JavaModelStatus.VERIFIED_OK);
1304	} finally {	1322	} finally {
1305	this.writtingRawClasspath = false;	1323	this.writtingRawClasspath = false;
1306	}	1324	}
1307	return true;	1325	return true;
1308	}	1326	}
		1327
		1328	public boolean writeAndCacheClasspath(JavaProject javaProject, final IClasspathEntry[] newRawClasspath, final IPath newOutputLocation) throws JavaModelException {
		1329	return writeAndCacheClasspath(javaProject, newRawClasspath, null, newOutputLocation);
		1330	}
		1331
1309	}	1332	}
1310		1333
1311	public static class PerWorkingCopyInfo implements IProblemRequestor {	1334	public static class PerWorkingCopyInfo implements IProblemRequestor {
Lines 1819-1824 Link Here
1819	return container;	1842	return container;
1820	}	1843	}
1821		1844
		1845	public IClasspathEntry[] getReferencedClasspathEntries(IClasspathEntry libraryEntry, IJavaProject project) {
		1846
		1847	IClasspathEntry[] referencedEntries = ((ClasspathEntry)libraryEntry).resolvedChainedLibraries();
		1848	PerProjectInfo perProjectInfo = getPerProjectInfo(project.getProject(), false);
		1849
		1850	if(perProjectInfo == null)
		1851	return referencedEntries;
		1852
		1853	List pathToReferencedEntries = new ArrayList(referencedEntries.length);
		1854	for (int index = 0; index < referencedEntries.length; index++) {
		1855
		1856	if (pathToReferencedEntries.contains(referencedEntries[index].getPath()))
		1857	continue;
		1858
		1859	IClasspathEntry persistedEntry = null;
		1860	if ((persistedEntry = (IClasspathEntry)perProjectInfo.rootPathToResolvedEntries.get(referencedEntries[index].getPath())) != null) {
		1861	// TODO: reconsider this - may want to copy the values instead of reference assignment?
		1862	referencedEntries[index] = persistedEntry;
		1863	}
		1864	pathToReferencedEntries.add(referencedEntries[index].getPath());
		1865	}
		1866	return referencedEntries;
		1867	}
		1868
1822	public DeltaProcessor getDeltaProcessor() {	1869	public DeltaProcessor getDeltaProcessor() {
1823	return this.deltaState.getDeltaProcessor();	1870	return this.deltaState.getDeltaProcessor();
1824	}	1871	}
Lines 3488-3494 Link Here
3488	} else {	3535	} else {
3489	IClasspathEntry[] entries;	3536	IClasspathEntry[] entries;
3490	try {	3537	try {
3491	entries = ((JavaProject) project).decodeClasspath(containerString, null/not interested in unknown elements/);	3538	entries = ((JavaProject) project).decodeClasspath(containerString, null/not interested in unknown elements/)[0];
3492	} catch (IOException e) {	3539	} catch (IOException e) {
3493	Util.log(e, "Could not recreate persisted container: \n" + containerString); //$NON-NLS-1$	3540	Util.log(e, "Could not recreate persisted container: \n" + containerString); //$NON-NLS-1$
3494	entries = JavaProject.INVALID_CLASSPATH;	3541	entries = JavaProject.INVALID_CLASSPATH;




import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;

import org.eclipse.core.runtime.content.IContentDescription;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.IScopeContext;
import org.eclipse.jdt.core.IClasspathAttribute;
import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.ICompilationUnit;

			return false;
		return true;
	}
	
	private static boolean areClasspathEqual(IClasspathEntry[] first, IClasspathEntry[] second) {
		if (first != second){
		    if (first == null) return false;
			int length = first.length;
			if (second == null || second.length != length)
				return false;
			for (int i = 0; i < length; i++) {
				if (!first[i].equals(second[i]))
					return false;
			}
		}
		return true;
	}

	/**
	 * Returns a canonicalized path from the given external path.

	/*
	 * Reads and decode an XML classpath string
	 */
	public IClasspathEntry[][] decodeClasspath(String xmlClasspath, Map unknownElements) throws IOException, ClasspathEntry.AssertionFailedException {

		ArrayList paths = new ArrayList();
		IClasspathEntry defaultOutput = null;

		if (!cpElement.getNodeName().equalsIgnoreCase("classpath")) { //$NON-NLS-1$
			throw new IOException(Messages.file_badFormat);
		}
		NodeList list = cpElement.getElementsByTagName(ClasspathEntry.TAG_CLASSPATHENTRY);
		int length = list.getLength();

		for (int i = 0; i < length; ++i) {

						defaultOutput = entry; // separate output
					} else {
						paths.add(entry);
					}
				}
			}
		}
		int pathSize = paths.size();
		IClasspathEntry[][] entries = new IClasspathEntry[2][];
		entries[0] = new IClasspathEntry[pathSize + (defaultOutput == null ? 0 : 1)];
		paths.toArray(entries[0]);
		if (defaultOutput != null) entries[0][pathSize] = defaultOutput; // ensure output is last item
		
		paths.clear();
		list = cpElement.getElementsByTagName(ClasspathEntry.TAG_REFERENCED_ENTRY);
		length = list.getLength();

		for (int i = 0; i < length; ++i) {
			Node node = list.item(i);
			if (node.getNodeType() == Node.ELEMENT_NODE) {
				IClasspathEntry entry = ClasspathEntry.elementDecode((Element)node, this, unknownElements);
				if (entry != null){
					paths.add(entry);
				}
			}
		}
		entries[1] = new IClasspathEntry[paths.size()];
		paths.toArray(entries[1]);

		paths.toArray(entries);
		if (defaultOutput != null) entries[pathSize] = defaultOutput; // ensure output is last item
		return entries;
	}


				reader.close();
			}

			if (!node.getNodeName().equalsIgnoreCase(ClasspathEntry.TAG_CLASSPATHENTRY)
					|| node.getNodeType() != Node.ELEMENT_NODE) {
				return null;
			}

	/**
	 * Returns the XML String encoding of the class path.
	 */
	protected String encodeClasspath(IClasspathEntry[] classpath, IClasspathEntry[] referencedEntries, IPath outputLocation, boolean indent, Map unknownElements) throws JavaModelException {
		try {
			ByteArrayOutputStream s = new ByteArrayOutputStream();
			OutputStreamWriter writer = new OutputStreamWriter(s, "UTF8"); //$NON-NLS-1$


			xmlWriter.startTag(ClasspathEntry.TAG_CLASSPATH, indent);
			for (int i = 0; i < classpath.length; ++i) {
				((ClasspathEntry)classpath[i]).elementEncode(xmlWriter, this.project.getFullPath(), indent, true, unknownElements, false);
			}

			if (outputLocation != null) {

				xmlWriter.printTag(ClasspathEntry.TAG_CLASSPATHENTRY, parameters, indent, true, true);
			}

			if (referencedEntries != null) {
				for (int i = 0; i < referencedEntries.length; ++i) {
					((ClasspathEntry) referencedEntries[i]).elementEncode(xmlWriter, this.project.getFullPath(), indent, true, unknownElements, true);
				}
			}
			
			xmlWriter.endTag(ClasspathEntry.TAG_CLASSPATH, indent, true/*insert new line*/);
			writer.flush();
			writer.close();

			OutputStreamWriter writer = new OutputStreamWriter(s, "UTF8"); //$NON-NLS-1$
			XMLWriter xmlWriter = new XMLWriter(writer, this, false/*don't print XML version*/);

			((ClasspathEntry)classpathEntry).elementEncode(xmlWriter, this.project.getFullPath(), true/*indent*/, true/*insert new line*/, null/*not interested in unknown elements*/, (classpathEntry.getReferencingEntry() != null));

			writer.flush();
			writer.close();

		IClasspathEntry[] classpath = perProjectInfo.rawClasspath;
		if (classpath != null) return classpath;

		classpath = perProjectInfo.readAndCacheClasspath(this)[0];

		if (classpath == JavaProject.INVALID_CLASSPATH)
			return defaultClasspath();

	}

	/**
	 * @see IJavaProject
	 */
	public IClasspathEntry[] getReferencedClasspathEntries() throws JavaModelException {
		return getPerProjectInfo().referencedEntries;
	}
	
	/**
	 * @see IJavaProject#getRequiredProjectNames()
	 */
	public String[] getRequiredProjectNames() throws JavaModelException {

	 * As a side effect, unknown elements are stored in the given map (if not null)
	 * Throws exceptions if the file cannot be accessed or is malformed.
	 */
	public IClasspathEntry[][] readFileEntriesWithException(Map unknownElements) throws CoreException, IOException, ClasspathEntry.AssertionFailedException {
		IFile rscFile = this.project.getFile(JavaProject.CLASSPATH_FILENAME);
		byte[] bytes;
		if (rscFile.exists()) {

				bytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(file);
			} catch (IOException e) {
				if (!file.exists())
					return new IClasspathEntry[][]{defaultClasspath(), ClasspathEntry.NO_ENTRIES};
				throw e;
			}
		}

	 * This includes the output entry.
	 * As a side effect, unknown elements are stored in the given map (if not null)
	 */
	private IClasspathEntry[][] readFileEntries(Map unkwownElements) {
		try {
			return readFileEntriesWithException(unkwownElements);
		} catch (CoreException e) {
			Util.log(e, "Exception while reading " + getPath().append(JavaProject.CLASSPATH_FILENAME)); //$NON-NLS-1$
			return new IClasspathEntry[][]{JavaProject.INVALID_CLASSPATH, ClasspathEntry.NO_ENTRIES};
		} catch (IOException e) {
			Util.log(e, "Exception while reading " + getPath().append(JavaProject.CLASSPATH_FILENAME)); //$NON-NLS-1$
			return new IClasspathEntry[][]{JavaProject.INVALID_CLASSPATH, ClasspathEntry.NO_ENTRIES};
		} catch (ClasspathEntry.AssertionFailedException e) {
			Util.log(e, "Exception while reading " + getPath().append(JavaProject.CLASSPATH_FILENAME)); //$NON-NLS-1$
			return new IClasspathEntry[][]{JavaProject.INVALID_CLASSPATH, ClasspathEntry.NO_ENTRIES};
		}
	}


	 */
	public IPath readOutputLocation() {
		// Read classpath file without creating markers nor logging problems
		IClasspathEntry[][] classpath = readFileEntries(null/*not interested in unknown elements*/);
		if (classpath[0] == JavaProject.INVALID_CLASSPATH)
			return defaultOutputLocation();

		// extract the output location
		IPath outputLocation = null;
		if (classpath[0].length > 0) {
			IClasspathEntry entry = classpath[0][classpath[0].length - 1];
			if (entry.getContentKind() == ClasspathEntry.K_OUTPUT) {
				outputLocation = entry.getPath();
			}

	 */
	public IClasspathEntry[] readRawClasspath() {
		// Read classpath file without creating markers nor logging problems
		IClasspathEntry[][] classpath = readFileEntries(null/*not interested in unknown elements*/);
		if (classpath[0] == JavaProject.INVALID_CLASSPATH)
			return defaultClasspath();

		// discard the output location
		if (classpath[0].length > 0) {
			IClasspathEntry entry = classpath[0][classpath[0].length - 1];
			if (entry.getContentKind() == ClasspathEntry.K_OUTPUT) {
				IClasspathEntry[] copy = new IClasspathEntry[classpath[0].length - 1];
				System.arraycopy(classpath[0], 0, copy, 0, copy.length);
				classpath[0] = copy;
			}
		}
		return classpath[0];
	}

	/**

		IJavaModelStatus unresolvedEntryStatus = JavaModelStatus.VERIFIED_OK;
		HashMap rawReverseMap = new HashMap();
		Map rootPathToResolvedEntries = new HashMap();
		IClasspathEntry[] referencedEntries = null;
	}
	
	public ResolvedClasspath resolveClasspath(IClasspathEntry[] rawClasspath, boolean usePreviousSession, boolean resolveChainedLibraries) throws JavaModelException {
		return resolveClasspath(rawClasspath, null, usePreviousSession, resolveChainedLibraries);
	}

	public ResolvedClasspath resolveClasspath(IClasspathEntry[] rawClasspath, IClasspathEntry[] referencedEntries, boolean usePreviousSession, boolean resolveChainedLibraries) throws JavaModelException {
		JavaModelManager manager = JavaModelManager.getJavaModelManager();
		ExternalFoldersManager externalFoldersManager = JavaModelManager.getExternalManager();
		ResolvedClasspath result = new ResolvedClasspath();

		Map referencedEntriesMap = new HashMap();
		List rawLibrariesPath = new ArrayList();
		LinkedHashSet resolvedEntries = new LinkedHashSet();
		
		if(resolveChainedLibraries) {
			for (int index = 0; index < rawClasspath.length; index++) {
				IClasspathEntry currentEntry = rawClasspath[index]; 
				if (currentEntry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
					rawLibrariesPath.add(ClasspathEntry.resolveDotDot(currentEntry.getPath()));
				}
			}
			if (referencedEntries != null) {
				// The Set is required to keep the order intact while the referencedEntriesMap (Map)
				// is used to map the referenced entries with path
				LinkedHashSet referencedEntriesSet = new LinkedHashSet();
				for (int index = 0; index < referencedEntries.length; index++) {
					IPath path = referencedEntries[index].getPath();
					if (!rawLibrariesPath.contains(path) && referencedEntriesMap.get(path) == null) {
						referencedEntriesMap.put(path, referencedEntries[index]);
						referencedEntriesSet.add(referencedEntries[index]);
					}
				}
				result.referencedEntries = new IClasspathEntry[referencedEntriesSet.size()];
				referencedEntriesSet.toArray(result.referencedEntries);
			}
		}
		
		int length = rawClasspath.length;
		for (int i = 0; i < length; i++) {


					if (resolvedEntry == null) {
						result.unresolvedEntryStatus = new JavaModelStatus(IJavaModelStatusConstants.CP_VARIABLE_PATH_UNBOUND, this, rawEntry.getPath());
					} else {
						// If the entry is already present in the rawReversetMap, it means the entry and the chained libraries
						// have already been processed. So, skip it.
						if (resolveChainedLibraries && resolvedEntry.getEntryKind() == IClasspathEntry.CPE_LIBRARY
													&& result.rawReverseMap.get(resolvedEntry.getPath()) == null) {
							// resolve Class-Path: in manifest
							ClasspathEntry[] extraEntries = ((ClasspathEntry) resolvedEntry).resolvedChainedLibraries();
							for (int j = 0, length2 = extraEntries.length; j < length2; j++) {
								if (!rawLibrariesPath.contains(extraEntries[j].getPath())) {
									addToResult(rawEntry, extraEntries[j], result, resolvedEntries, externalFoldersManager, referencedEntriesMap, true);
								}
							}
						}
						addToResult(rawEntry, resolvedEntry, result, resolvedEntries, externalFoldersManager, referencedEntriesMap, false);
					}
					break;


							// resolve ".." in library path
							cEntry = cEntry.resolvedDotDot();
							
							if (resolveChainedLibraries && result.rawReverseMap.get(cEntry.getPath()) == null) {
								// resolve Class-Path: in manifest
								ClasspathEntry[] extraEntries = cEntry.resolvedChainedLibraries();
								for (int k = 0, length2 = extraEntries.length; k < length2; k++) {
									if (!rawLibrariesPath.contains(extraEntries[k].getPath())) {
										addToResult(rawEntry, extraEntries[k], result, resolvedEntries, externalFoldersManager, referencedEntriesMap, true);
									}
								}
							}
						}
						addToResult(rawEntry, cEntry, result, resolvedEntries, externalFoldersManager, referencedEntriesMap, false);
					}
					break;


					// resolve ".." in library path
					resolvedEntry = ((ClasspathEntry) rawEntry).resolvedDotDot();
					
					if (resolveChainedLibraries && result.rawReverseMap.get(resolvedEntry.getPath()) == null) {
						// resolve Class-Path: in manifest
						ClasspathEntry[] extraEntries = ((ClasspathEntry) resolvedEntry).resolvedChainedLibraries();
						for (int k = 0, length2 = extraEntries.length; k < length2; k++) {
							if (!rawLibrariesPath.contains(extraEntries[k].getPath())) {
								addToResult(rawEntry, extraEntries[k], result, resolvedEntries, externalFoldersManager, referencedEntriesMap, true);
							}
						}
					}

					addToResult(rawEntry, resolvedEntry, result, resolvedEntries, externalFoldersManager, referencedEntriesMap, false);
					break;
				default :
					addToResult(rawEntry, resolvedEntry, result, resolvedEntries, externalFoldersManager, referencedEntriesMap, false);
					break;
			}
		}

		return result;
	}

	private void addToResult(IClasspathEntry rawEntry, IClasspathEntry resolvedEntry, ResolvedClasspath result,
			LinkedHashSet resolvedEntries, ExternalFoldersManager externalFoldersManager,
			Map oldChainedEntriesMap, boolean addAsChainedEntry) {

		IPath resolvedPath;
		// If it's already been resolved, do not add to resolvedEntries or newChainedEntries lists
		if (result.rawReverseMap.get(resolvedPath = resolvedEntry.getPath()) == null) {
			result.rawReverseMap.put(resolvedPath, rawEntry);
			result.rootPathToResolvedEntries.put(resolvedPath, resolvedEntry);
			resolvedEntries.add(resolvedEntry);
			if (addAsChainedEntry) {
				IClasspathEntry chainedEntry = null;
				if (rawEntry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {

					chainedEntry = (ClasspathEntry) oldChainedEntriesMap.get(resolvedPath);
					if (chainedEntry != null) {
						// This is required to keep the attributes if any added by the user in
						// the previous session such as source attachment path etc.
						copyFromOldChainedEntry((ClasspathEntry) resolvedEntry, (ClasspathEntry) chainedEntry);
					}
				}
			}
		}
		if (resolvedEntry.getEntryKind() == IClasspathEntry.CPE_LIBRARY && ExternalFoldersManager.isExternalFolderPath(resolvedPath)) {
			externalFoldersManager.addFolder(resolvedPath); // no-op if not an external folder or if already registered
		}
	}

	private void copyFromOldChainedEntry(ClasspathEntry resolvedEntry, ClasspathEntry chainedEntry) {
		IPath path = chainedEntry.getSourceAttachmentPath();
		if ( path != null) {
			resolvedEntry.sourceAttachmentPath = path;
		}
		path = chainedEntry.getSourceAttachmentRootPath();
		if (path != null) {
			resolvedEntry.sourceAttachmentRootPath = path;
		}
		IClasspathAttribute[] attributes = chainedEntry.getExtraAttributes();
		if (attributes != null) {
			resolvedEntry.extraAttributes = attributes;
		}
	}
	
	/*
	 * Resolve the given perProjectInfo's raw classpath and store the resolved classpath in the perProjectInfo.
	 */

			}

			// get raw info inside a synchronized block to ensure that it is consistent
			IClasspathEntry[][] classpath = new IClasspathEntry[2][];
			int timeStamp;
			synchronized (perProjectInfo) {
				classpath[0] = perProjectInfo.rawClasspath;
				classpath[1] = perProjectInfo.referencedEntries;
				// Checking null only for rawClasspath enough
				if (classpath[0] == null)
					classpath = perProjectInfo.readAndCacheClasspath(this);
				timeStamp = perProjectInfo.rawTimeStamp;
			}
			
			ResolvedClasspath result = resolveClasspath(rawClasspath, usePreviousSession, true/*resolve chained libraries*/);

			ResolvedClasspath result = resolveClasspath(classpath[0], classpath[1], usePreviousSession, true/*resolve chained libraries*/);
			
			if (CP_RESOLUTION_BP_LISTENERS != null)
				breakpoint(2, this);

			// store resolved info along with the raw info to ensure consistency
			perProjectInfo.setResolvedClasspath(result.resolvedClasspath, result.referencedEntries, result.rawReverseMap, result.rootPathToResolvedEntries, usePreviousSession ? PerProjectInfo.NEED_RESOLUTION : result.unresolvedEntryStatus, timeStamp, addClasspathChange);
		} finally {
			if (!isClasspathBeingResolved) {
				manager.setClasspathBeingResolved(this, false);

	 * @return boolean Return whether the .classpath file was modified.
	 * @throws JavaModelException
	 */
	public boolean writeFileEntries(IClasspathEntry[] newClasspath, IClasspathEntry[] referencedEntries, IPath newOutputLocation) throws JavaModelException {

		if (!this.project.isAccessible()) return false;

		Map unknownElements = new HashMap();
		IClasspathEntry[][] fileEntries = readFileEntries(unknownElements);
		if (fileEntries[0] != JavaProject.INVALID_CLASSPATH && 
				areClasspathsEqual(newClasspath, newOutputLocation, fileEntries[0])
				&& areClasspathEqual(referencedEntries, fileEntries[1])) {
			// no need to save it, it is the same
			return false;
		}

		// actual file saving
		try {
			setSharedProperty(JavaProject.CLASSPATH_FILENAME, encodeClasspath(newClasspath, referencedEntries, newOutputLocation, true, unknownElements));
			return true;
		} catch (CoreException e) {
			throw new JavaModelException(e);
		}
	}
	public boolean writeFileEntries(IClasspathEntry[] newClasspath, IPath newOutputLocation) throws JavaModelException {
		return writeFileEntries(newClasspath, ClasspathEntry.NO_ENTRIES, newOutputLocation);
	}

	/**
	 * Update the Java command in the build spec (replace existing one if present,

			boolean canModifyResources,
			IProgressMonitor monitor)
			throws JavaModelException {
		setRawClasspath(newRawClasspath, null, newOutputLocation, canModifyResources, monitor);
		try {
			if (newRawClasspath == null) //are we already with the default classpath
				newRawClasspath = defaultClasspath();

			SetClasspathOperation op =
				new SetClasspathOperation(
					this,
					newRawClasspath,
					newOutputLocation,
					canModifyResources);
			op.runOperation(monitor);
		} catch (JavaModelException e) {
			JavaModelManager.getJavaModelManager().getDeltaProcessor().flush();
			throw e;
		}
	}

	/**

			true/*can change resource (as per API contract)*/,
			monitor);
	}
	
	public void setRawClasspath(IClasspathEntry[] entries, IClasspathEntry[] referencedEntries, IPath outputLocation,
			IProgressMonitor monitor) throws JavaModelException {
		setRawClasspath(entries, referencedEntries, outputLocation, true, monitor);
	}
	
	protected void setRawClasspath(IClasspathEntry[] newRawClasspath, IClasspathEntry[] referencedEntries, IPath newOutputLocation,
			boolean canModifyResources,	IProgressMonitor monitor) throws JavaModelException {

		try {
			if (newRawClasspath == null) //are we already with the default classpath
				newRawClasspath = defaultClasspath();

			SetClasspathOperation op =
				new SetClasspathOperation(
					this,
					newRawClasspath,
					referencedEntries,
					newOutputLocation,
					canModifyResources);
			op.runOperation(monitor);
		} catch (JavaModelException e) {
			JavaModelManager.getJavaModelManager().getDeltaProcessor().flush();
			throw e;
		}
	}

	/**
	 * @see IJavaProject




/*******************************************************************************
 * Copyright (c) 2000, 2010 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

	}
	return rawEntry;
}
/*
 * @see IPackageFragmentRoot
 */
public IClasspathEntry getResolvedClasspathEntry() throws JavaModelException {
	IClasspathEntry resolvedEntry = null;
	JavaProject project = (JavaProject)getJavaProject();
	project.getResolvedClasspath(); // force the reverse rawEntry cache to be populated
	Map rootPathToResolvedEntries = project.getPerProjectInfo().rootPathToResolvedEntries;
	if (rootPathToResolvedEntries != null) {
		resolvedEntry = (IClasspathEntry) rootPathToResolvedEntries.get(getPath());
	}
	if (resolvedEntry == null) {
		throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_NOT_ON_CLASSPATH, this));
	}
	return resolvedEntry;
}


public IResource resource() {




/*******************************************************************************
 * Copyright (c) 2000, 2010 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

public class SetClasspathOperation extends ChangeClasspathOperation {

	IClasspathEntry[] newRawClasspath;
	IClasspathEntry[] referencedEntries;
	IPath newOutputLocation;
	JavaProject project;

	public SetClasspathOperation(
		JavaProject project,
		IClasspathEntry[] newRawClasspath,
		IPath newOutputLocation,
		boolean canChangeResource) {

		this(project, newRawClasspath, null, newOutputLocation, canChangeResource);
	}
	
	/**
	 * When executed, this operation sets the raw classpath and output location of the given project.
	 */
	public SetClasspathOperation(
		JavaProject project,
		IClasspathEntry[] newRawClasspath,
		IClasspathEntry[] referencedEntries,
		IPath newOutputLocation,
		boolean canChangeResource) {

		super(new IJavaElement[] { project }, canChangeResource);
		this.project = project;
		this.newRawClasspath = newRawClasspath;
		this.referencedEntries = referencedEntries;
		this.newOutputLocation = newOutputLocation;
	}


		try {
			// set raw classpath and null out resolved info
			PerProjectInfo perProjectInfo = this.project.getPerProjectInfo();
			ClasspathChange classpathChange = perProjectInfo.setRawClasspath(this.newRawClasspath, this.referencedEntries, this.newOutputLocation, JavaModelStatus.VERIFIED_OK/*format is ok*/);

			// if needed, generate delta, update project ref, create markers, ...
			classpathChanged(classpathChange);




// All specified tests which do not belong to the class are skipped...
static {
	// Names of tests to run: can be "testBugXXXX" or "BugXXXX")
//	TESTS_PREFIX = "testBug252341c";
//	TESTS_NAMES = new String[] {"testClasspathWithNonExistentLibraryEntry"};
//	TESTS_NUMBERS = new int[] { 23, 28, 38 };
//	TESTS_RANGE = new int[] { 21, 38 };
}

		deleteExternalResource("lib.jar");
	}
}
/**
 * @bug 252431:New API is needed to better identify referenced jars in the Class-Path: entry
 * Test that 1) referenced libraries are added to the resolved classpath in the right order
 * 			 2) referenced libraries are added to the appropriate referencing library in the correct order
 * 			 3) referenced libraries and top-level libraries retain the source attachment and source attachment root path
 * 			 4) referenced libraries point to the correct entry as their referencingEntry. 
 * 			 5) referenced libraries and their attributes are persisted in the .classpath file
 * 
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=252431"
 * @throws Exception
 */ 
public void testBug252341a() throws Exception {
	try {
		IJavaProject p = createJavaProject("P");
		addLibrary(p, "lib1.jar", "abc.zip", new String[0], 
			new String[] {
				"META-INF/MANIFEST.MF",
				"Manifest-Version: 1.0\n" +
				"Class-Path: lib2.jar lib3.jar\n",
			},
			JavaCore.VERSION_1_4);
		createFile("/P/lib2.jar", "");
		createFile("/P/lib3.jar", "");
		
		// Test referenced entries are included in the right order in the resolved classpath
		IClasspathEntry[] resolvedClasspath = p.getResolvedClasspath(true);
		assertClasspathEquals(resolvedClasspath, 
				"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" + 
				""+ getExternalJCLPathString() + "[CPE_LIBRARY][K_BINARY][isExported:false]\n" + 
				"/P/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" + 
				"/P/lib3.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" + 
				"/P/lib1.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/abc.zip][isExported:true]");
		
		IClasspathEntry[] rawClasspath = p.getRawClasspath();
		assertClasspathEquals(rawClasspath,
				"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" + 
				"JCL_LIB[CPE_VARIABLE][K_SOURCE][isExported:false]\n" + 
				"/P/lib1.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/abc.zip][isExported:true]");

		// Test referenced entries for a particular entry appear in the right order and the referencingEntry
		// attribute has the correct value
		IClasspathEntry[] chains = JavaCore.getReferencedClasspathEntries(rawClasspath[2], p);
		assertClasspathEquals(chains, 
				"/P/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" + 
				"/P/lib3.jar[CPE_LIBRARY][K_BINARY][isExported:true]");

		assertSame("Referencing Entry", rawClasspath[2], chains[0].getReferencingEntry());
		assertSame("Referencing Entry", rawClasspath[2], chains[1].getReferencingEntry());
		
		// Test a newly created library entry with similar attributes but without any referencing entry is equal to 
		// the original referenced entry
		IClasspathEntry tempLibEntry = JavaCore.newLibraryEntry(chains[0].getPath(), chains[0].getSourceAttachmentPath(), chains[0].getSourceAttachmentRootPath(), true);
		assertEquals("Library Entry", tempLibEntry, chains[0]);
		
		// Test the source attachment and other attributes added to the referenced entries are stored and retrieved properly
		assertEquals("source attachment", resolvedClasspath[4].getSourceAttachmentPath().toPortableString(), "/P/abc.zip");
		assertNull("source attachment", chains[0].getSourceAttachmentPath());
		assertNull("source attachment", chains[1].getSourceAttachmentPath());
		assertNull("source attachment root", chains[0].getSourceAttachmentRootPath());
		assertNull("source attachment root", chains[1].getSourceAttachmentRootPath());

		((ClasspathEntry)chains[0]).sourceAttachmentPath = new Path("/P/efg.zip");
		((ClasspathEntry)chains[1]).sourceAttachmentPath = new Path("/P/xyz.zip");
		((ClasspathEntry)chains[0]).sourceAttachmentRootPath = new Path("/src2");
		((ClasspathEntry)chains[1]).sourceAttachmentRootPath = new Path("/src3");

		IClasspathAttribute javadocLoc = JavaCore.newClasspathAttribute("javadoc_location", "/P/efg.zip");
		((ClasspathEntry)chains[0]).extraAttributes = new IClasspathAttribute[]{javadocLoc};
		
		p.setRawClasspath(rawClasspath, chains, p.getOutputLocation(), null);
		
		// Test the .classpath file contains all the referenced entries and their attributes
		String contents = new String (org.eclipse.jdt.internal.core.util.Util.getResourceContentsAsCharArray(getFile("/P/.classpath")));
		assertSourceEquals(
			"Unexpected content",
			"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + 
			"<classpath>\n" + 
			"	<classpathentry kind=\"src\" path=\"\"/>\n" + 
			"	<classpathentry kind=\"var\" path=\"JCL_LIB\"/>\n" + 
			"	<classpathentry exported=\"true\" kind=\"lib\" path=\"lib1.jar\" sourcepath=\"abc.zip\"/>\n" + 
			"	<classpathentry kind=\"output\" path=\"\"/>\n" + 
			"	<referencedentry exported=\"true\" kind=\"lib\" path=\"lib2.jar\" rootpath=\"/src2\" sourcepath=\"efg.zip\">\n" + 
			"		<attributes>\n" + 
			"			<attribute name=\"javadoc_location\" value=\"/P/efg.zip\"/>\n" + 
			"		</attributes>\n" + 
			"	</referencedentry>\n" + 
			"	<referencedentry exported=\"true\" kind=\"lib\" path=\"lib3.jar\" rootpath=\"/src3\" sourcepath=\"xyz.zip\"/>\n" + 
			"</classpath>\n",
			contents);
		
		p.close();
		p.open(null);
		rawClasspath = p.getRawClasspath();
		resolvedClasspath = p.getResolvedClasspath(true);

		assertClasspathEquals(rawClasspath,
				"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" + 
				"JCL_LIB[CPE_VARIABLE][K_SOURCE][isExported:false]\n" + 
				"/P/lib1.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/abc.zip][isExported:true]");

		assertClasspathEquals(resolvedClasspath, 
				"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" + 
				""+ getExternalJCLPathString() + "[CPE_LIBRARY][K_BINARY][isExported:false]\n" + 
				"/P/lib2.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/efg.zip][rootPath:/src2][isExported:true][attributes:javadoc_location=/P/efg.zip]\n" + 
				"/P/lib3.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/xyz.zip][rootPath:/src3][isExported:true]\n" + 
				"/P/lib1.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/abc.zip][isExported:true]");
		
	} finally {
		deleteProject("P");
	}
}
/**
 * Additional tests for bug 252431.
 * When multiple libraries have one or more common referenced library in their MANIFEST
 * 1) The common referenced libries are added to the first library entry in the raw classpath
 * 2) Removing one of the top-level library from the raw classpath doesn't remove the referenced
 *    entry that was commonly referenced by another entry and the referenced entry's source
 *    attachment and other attributes are retained.
 * 3) Passing a NULL referencedEntries array retains the referenced entries
 * 4) Passing an empty array as referencedEntries clears the earlier referenced entries 
 * 
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=252431"
 * @throws Exception
 */
public void testBug252341b() throws Exception {
	try {
		IJavaProject p = createJavaProject("P");
		addLibrary(p, "lib1.jar", null, new String[0], 
			new String[] {
				"META-INF/MANIFEST.MF",
				"Manifest-Version: 1.0\n" +
				"Class-Path: lib3.jar lib4.jar\n",
			},
			JavaCore.VERSION_1_4);
		
		addLibrary(p, "lib2.jar", null, new String[0], 
				new String[] {
					"META-INF/MANIFEST.MF",
					"Manifest-Version: 1.0\n" +
					"Class-Path: lib3.jar lib5.jar\n",
				},
				JavaCore.VERSION_1_4);
		createFile("/P/lib3.jar", "");
		createFile("/P/lib4.jar", "");
		createFile("/P/lib5.jar", "");
		
		// Test that the referenced entries are not included in the raw classpath
		IClasspathEntry[] rawClasspath = p.getRawClasspath();
		assertClasspathEquals(
				rawClasspath,
				"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" + 
				"JCL_LIB[CPE_VARIABLE][K_SOURCE][isExported:false]\n" + 
				"/P/lib1.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" + 
				"/P/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:true]");

		IClasspathEntry[] rawEntries = new IClasspathEntry[2];
		rawEntries[0] = JavaCore.newLibraryEntry(new Path("/P/lib1.jar"), null, null, true);
		rawEntries[1] = JavaCore.newLibraryEntry(new Path("/P/lib2.jar"), null, null, true);
		
		// Test that the referenced entries are included in the raw classpath and in the right order
		IClasspathEntry[] resolvedClasspath = p.getResolvedClasspath(true);
		assertClasspathEquals(resolvedClasspath, 
				"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" + 
				""+ getExternalJCLPathString() + "[CPE_LIBRARY][K_BINARY][isExported:false]\n" + 
				"/P/lib3.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" + 
				"/P/lib4.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" + 
				"/P/lib1.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" + 
				"/P/lib5.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" + 
				"/P/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:true]");

		// Test that the referenced classpath entries has the appropriate referencingEntry value
		IClasspathEntry[] chains = JavaCore.getReferencedClasspathEntries(rawEntries[0], p); 
		assertClasspathEquals(
				chains, 
				"/P/lib3.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" + 
				"/P/lib4.jar[CPE_LIBRARY][K_BINARY][isExported:true]");
		assertEquals("Referencing Entry" , rawEntries[0], chains[0].getReferencingEntry()); 
		assertEquals("Referencing Entry" , rawEntries[0], chains[1].getReferencingEntry()); 

		chains = JavaCore.getReferencedClasspathEntries(rawEntries[1], p);
		assertClasspathEquals(
				chains, 
				"/P/lib3.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" + 
				"/P/lib5.jar[CPE_LIBRARY][K_BINARY][isExported:true]");
		
		assertEquals("Referencing Entry" , rawEntries[0], chains[0].getReferencingEntry());
		assertEquals("Referencing Entry" , rawEntries[1], chains[1].getReferencingEntry());
		
//		// Test IPackageFragmentRoot#getResolvedClasspathEntry
		IPackageFragmentRoot[] roots = p.getPackageFragmentRoots();
		assertEquals("Package fragment root", roots[2].getResolvedClasspathEntry(), resolvedClasspath[2]);
		assertEquals("Package fragment root", roots[3].getResolvedClasspathEntry(), resolvedClasspath[3]);
		assertEquals("Package fragment root", roots[4].getResolvedClasspathEntry(), resolvedClasspath[4]);
		assertEquals("Package fragment root", roots[5].getResolvedClasspathEntry(), resolvedClasspath[5]);
		assertEquals("Package fragment root", roots[6].getResolvedClasspathEntry(), resolvedClasspath[6]);
		
		// Test the attributes added to the referenced classpath entries are stored and retrieved properly
		((ClasspathEntry)chains[0]).sourceAttachmentPath = new Path("/P/efg.zip");
		((ClasspathEntry)chains[1]).sourceAttachmentPath = new Path("/P/xyz.zip");
		((ClasspathEntry)chains[0]).sourceAttachmentRootPath = new Path("/src2");
		((ClasspathEntry)chains[1]).sourceAttachmentRootPath = new Path("/src3");

		IClasspathAttribute javadocLoc = JavaCore.newClasspathAttribute("javadoc_location", "/P/efg.zip");
		((ClasspathEntry)chains[0]).extraAttributes = new IClasspathAttribute[]{javadocLoc};

		p.setRawClasspath(rawClasspath, chains, p.getOutputLocation(), null);
		resolvedClasspath = p.getResolvedClasspath(true);
		
		assertClasspathEquals(resolvedClasspath,
				"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" +
				""+ getExternalJCLPathString() + "[CPE_LIBRARY][K_BINARY][isExported:false]\n" +
				"/P/lib3.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/efg.zip][rootPath:/src2][isExported:true][attributes:javadoc_location=/P/efg.zip]\n" +
				"/P/lib4.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
				"/P/lib1.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
				"/P/lib5.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/xyz.zip][rootPath:/src3][isExported:true]\n" +
				"/P/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:true]");
		
		// Test that removing any of the referencing entry from the raw classpath has the correct effect 
		// on the resolved classpath. Also test passing referencedEntries = null retains the existing
		// referenced entries
		IClasspathEntry[] newRawClasspath = new IClasspathEntry[rawClasspath.length-1];
		System.arraycopy(rawClasspath, 0, newRawClasspath, 0, 2);
		System.arraycopy(rawClasspath, 3, newRawClasspath, 2, 1);
		p.setRawClasspath(newRawClasspath, null, p.getOutputLocation(), null);
		resolvedClasspath = p.getResolvedClasspath(true);
		assertClasspathEquals(resolvedClasspath,
				"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" +
				""+ getExternalJCLPathString() + "[CPE_LIBRARY][K_BINARY][isExported:false]\n" +
				"/P/lib3.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/efg.zip][rootPath:/src2][isExported:true][attributes:javadoc_location=/P/efg.zip]\n" +
				"/P/lib5.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/xyz.zip][rootPath:/src3][isExported:true]\n" +
				"/P/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:true]");

		// Test that passing empty array of referencedEntries clears all the earlier ones. 
		p.setRawClasspath(newRawClasspath, new IClasspathEntry[]{}, p.getOutputLocation(), null);
		resolvedClasspath = p.getResolvedClasspath(true);
		assertClasspathEquals(resolvedClasspath,
				"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" +
				""+ getExternalJCLPathString() + "[CPE_LIBRARY][K_BINARY][isExported:false]\n" +
				"/P/lib3.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
				"/P/lib5.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
				"/P/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:true]");

	} finally {
		deleteProject("P");
	}
}
/**
 * Additional tests for bug 252431.
 * Test that duplicate referenced entries or entries that are already present in the raw classpath
 * are excluded from the referenced entries when invoking 
 * {@link IJavaProject#setRawClasspath(IClasspathEntry[], IClasspathEntry[], IPath, IProgressMonitor)}
 * 
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=252431"
 * @throws Exception
 */
public void testBug252341c() throws Exception {
	try {
		IJavaProject p = createJavaProject("P");
		addLibrary(p, "lib1.jar", null, new String[0], 
			new String[] {
				"META-INF/MANIFEST.MF",
				"Manifest-Version: 1.0\n" +
				"Class-Path: lib3.jar lib4.jar\n",
			},
			JavaCore.VERSION_1_4);
		
		addLibrary(p, "lib2.jar", null, new String[0], 
				new String[] {
					"META-INF/MANIFEST.MF",
					"Manifest-Version: 1.0\n" +
					"Class-Path: lib3.jar lib5.jar\n",
				},
				JavaCore.VERSION_1_4);
		createFile("/P/lib3.jar", "");
		createFile("/P/lib4.jar", "");
		createFile("/P/lib5.jar", "");
		
		IClasspathEntry[] rawClasspath = p.getRawClasspath();
		
		IClasspathEntry[] rawEntries = new IClasspathEntry[2];
		rawEntries[0] = JavaCore.newLibraryEntry(new Path("/P/lib1.jar"), null, null, true);
		rawEntries[1] = JavaCore.newLibraryEntry(new Path("/P/lib2.jar"), null, null, true);
		
		// Test that the referenced classpath entries has the appropriate referencingEntry value
		IClasspathEntry[] chains = JavaCore.getReferencedClasspathEntries(rawEntries[0], p);

		IClasspathEntry[] referencedEntries = new IClasspathEntry[5];
		referencedEntries[0] = chains[0]; 
		referencedEntries[1] = chains[1]; 
		
		chains = JavaCore.getReferencedClasspathEntries(rawEntries[1], p);

		referencedEntries[2] = chains[0];
		referencedEntries[3] = chains[1];
		referencedEntries[4] = chains[1];
		
		p.setRawClasspath(rawClasspath, referencedEntries, p.getOutputLocation(), null);
		
		p.close();
		p.open(null);
		
		IClasspathEntry[] storedReferencedEnties = p.getReferencedClasspathEntries();
		assertClasspathEquals(storedReferencedEnties, 
				"/P/lib3.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" + 
				"/P/lib4.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" + 
				"/P/lib5.jar[CPE_LIBRARY][K_BINARY][isExported:true]");
	}
	finally {
		deleteProject("P");
	}
}

}

Return to bug 281551

Lines 4587-4592 Link Here

(-)model/org/eclipse/jdt/core/JavaCore.java (+27 lines)
4587	false, // no access rules to combine	4587	false, // no access rules to combine
4588	extraAttributes);	4588	extraAttributes);
4589	}	4589	}
		4590
		4591	/**
		4592	* Returns an array of classpath entries that are referenced directly or indirectly
		4593	* by a given classpath entry. For the entry kind {@link IClasspathEntry#CPE_LIBRARY},
		4594	* the method returns the libraries that are included in the Class-Path section of
		4595	* the MANIFEST.MF file. If a referenced JAR file has further references to other library
		4596	* entries, they are processed recursively and added to the list. For entry kinds other
		4597	* than {@link IClasspathEntry#CPE_LIBRARY}, this method returns an empty array.
		4598	* <p>
		4599	* If a referenced entry has already been stored
		4600	* in the given project's .classpath, the stored attributes are populated in the corresponding
		4601	* referenced entry. For more details on storing referenced entries see
		4602	* see {@link IJavaProject#setRawClasspath(IClasspathEntry[], IClasspathEntry[], IPath,
		4603	* IProgressMonitor)}.
		4604	* </p>
		4605	*
		4606	* @param libraryEntry the library entry whose referenced entries are sought
		4607	* @param project project where the persisted referenced entries to be retrieved from
		4608	* @return an array of classpath entries that are referenced directly or indirectly by the given entry.
		4609	* If not applicable, returns an emptry array.
		4610	* @since 3.6
		4611	*/
		4612	public static IClasspathEntry[] getReferencedClasspathEntries(IClasspathEntry libraryEntry, IJavaProject project) {
		4613	JavaModelManager manager = JavaModelManager.getJavaModelManager();
		4614	return manager.getReferencedClasspathEntries(libraryEntry, project);
		4615	}
		4616
4590	/**	4617	/**
4591	* Removed the given classpath variable. Does nothing if no value was	4618	* Removed the given classpath variable. Does nothing if no value was
4592	* set for this classpath variable.	4619	* set for this classpath variable.

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/core/IClasspathEntry.java (-1 / +23 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 418-423 Link Here
418	*/	418	*/
419	IPath getSourceAttachmentRootPath();	419	IPath getSourceAttachmentRootPath();
420		420
		421
		422	/**
		423	* Returns the classpath entry that is making a reference to this classpath entry. For entry kinds
		424	* {@link #CPE_LIBRARY}, the return value is the entry that is representing the JAR that includes
		425	* <code>this</code> in the MANIFEST.MF file's Class-Path section. For entry kinds other than
		426	* {@link #CPE_LIBRARY}, this returns null. For those entries that are on the raw classpath already,
		427	* this returns <code>null</code>
		428	* <p>
		429	* It is possible that multiple library entries refer to the same entry
		430	* via the MANIFEST.MF file. In those cases, this method returns the first classpath entry
		431	* that appears in the raw classpath. However, this does not mean that the other referencing
		432	* entries do not relate to their referenced entries.
		433	* See {@link JavaCore#getReferencedClasspathEntries(IClasspathEntry, IJavaProject)} for
		434	* more details.
		435	* </p>
		436	*
		437	* @return the classpath entry that is referencing this entry or <code>null</code> if
		438	* not applicable.
		439	* @since 3.6
		440	*/
		441	IClasspathEntry getReferencingEntry();
		442
421	/**	443	/**
422	* Returns whether this entry is exported to dependent projects.	444	* Returns whether this entry is exported to dependent projects.
423	* Always returns <code>false</code> for source entries (kind	445	* Always returns <code>false</code> for source entries (kind

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/core/IJavaProject.java (-1 / +49 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 1008-1013 Link Here
1008	void setRawClasspath(IClasspathEntry[] entries, boolean canModifyResources, IProgressMonitor monitor) throws JavaModelException;	1008	void setRawClasspath(IClasspathEntry[] entries, boolean canModifyResources, IProgressMonitor monitor) throws JavaModelException;
1009		1009
1010	/**	1010	/**
		1011	* Works same as {@link #setRawClasspath(IClasspathEntry[], IPath, IProgressMonitor)} and
		1012	* additionally allows persisting the given array of referenced entries for this project.
		1013	* The referenced entries and their attributes are stores in the .classpath file of this
		1014	* project. For details on referenced entries, see
		1015	* {@link JavaCore#getReferencedClasspathEntries(IClasspathEntry, IJavaProject)}
		1016	* and {@link IClasspathEntry#getReferencingEntry()}.
		1017	* <p>
		1018	* Since the referenced entries are stored in the .classpath file, clients can store additional
		1019	* information that belong to these entries and retrieve them across sessions, though the referenced
		1020	* entries themselves may not be present in the raw classpath. By passing a <code>null</code>
		1021	* referencedEntries, clients can choose not to modify the already persisted referenced entries,
		1022	* which is fully equivalent to {@link #setRawClasspath(IClasspathEntry[], IPath, IProgressMonitor)}.
		1023	* If an empty array is passed as referencedEntries, the already persisted referenced entries,
		1024	* if any, will be cleared.
		1025	* </p> <p>
		1026	* If there are duplicates of a referenced entry or if any of the <code>referencedEntries</code>
		1027	* is already present in the raw classpath(<code>entries</code>) those referenced entries will
		1028	* be excluded and will not be persisted.
		1029	*</p>
		1030	* @param entries a list of classpath entries
		1031	* @param referencedEntries the list of referenced classpath entries to be persisted
		1032	* @param outputLocation the default output location
		1033	* @param monitor the given progress monitor
		1034	* @exception JavaModelException if the classpath could not be set. Reasons include:
		1035	* <ul>
		1036	* <li> This Java element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
		1037	* <li> The classpath is being modified during resource change event notification (CORE_EXCEPTION)
		1038	* <li> The classpath failed the validation check as defined by {@link JavaConventions#validateClasspath(IJavaProject, IClasspathEntry[], IPath)}
		1039	* </ul>
		1040	* @see IClasspathEntry
		1041	* @see #getReferencedClasspathEntries()
		1042	* @since 3.6
		1043	*/
		1044	void setRawClasspath(IClasspathEntry[] entries, IClasspathEntry[] referencedEntries, IPath outputLocation,
		1045	IProgressMonitor monitor) throws JavaModelException;
		1046
		1047	/**
		1048	* Returns the list of referenced classpath entries stored in the .classpath file of <code>this</code>
		1049	* java project. Clients can store the referenced classpath entries using
		1050	* {@link #setRawClasspath(IClasspathEntry[], IClasspathEntry[], IPath, IProgressMonitor)}
		1051	*
		1052	* @throws JavaModelException
		1053	* @return an array of referenced classpath entries stored for this java project
		1054	* @since 3.6
		1055	*/
		1056	IClasspathEntry[] getReferencedClasspathEntries() throws JavaModelException;
		1057
		1058	/**
1011	* Sets the classpath of this project using a list of classpath entries. In particular such a classpath may contain	1059	* Sets the classpath of this project using a list of classpath entries. In particular such a classpath may contain
1012	* classpath variable entries. Classpath variable entries can be resolved individually ({@link JavaCore#getClasspathVariable(String)}),	1060	* classpath variable entries. Classpath variable entries can be resolved individually ({@link JavaCore#getClasspathVariable(String)}),
1013	* or the full classpath can be resolved at once using the helper method {@link #getResolvedClasspath(boolean)}.	1061	* or the full classpath can be resolved at once using the helper method {@link #getResolvedClasspath(boolean)}.

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/core/IPackageFragmentRoot.java (-1 / +13 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 311-316 Link Here
311	* @since 2.0	311	* @since 2.0
312	*/	312	*/
313	IClasspathEntry getRawClasspathEntry() throws JavaModelException;	313	IClasspathEntry getRawClasspathEntry() throws JavaModelException;
		314
		315	/**
		316	* Returns the first resolved classpath entry that corresponds to this package fragment root.
		317	* A resolved classpath entry is said to correspond to a root if the path of the resolved
		318	* entry is equal to the root's path.
		319	*
		320	* @return the first resolved classpath entry that corresponds to this package fragment root
		321	* @throws JavaModelException if this element does not exist or if an
		322	* exception occurs while accessing its corresponding resource.
		323	* @since 3.6
		324	*/
		325	IClasspathEntry getResolvedClasspathEntry() throws JavaModelException;
314		326
315	/**	327	/**
316	* Returns the absolute path to the source archive attached to	328	* Returns the absolute path to the source archive attached to

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/internal/core/PackageFragmentRoot.java (-1 / +17 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 554-559 Link Here
554	}	554	}
555	return rawEntry;	555	return rawEntry;
556	}	556	}
		557	/*
		558	* @see IPackageFragmentRoot
		559	*/
		560	public IClasspathEntry getResolvedClasspathEntry() throws JavaModelException {
		561	IClasspathEntry resolvedEntry = null;
		562	JavaProject project = (JavaProject)getJavaProject();
		563	project.getResolvedClasspath(); // force the reverse rawEntry cache to be populated
		564	Map rootPathToResolvedEntries = project.getPerProjectInfo().rootPathToResolvedEntries;
		565	if (rootPathToResolvedEntries != null) {
		566	resolvedEntry = (IClasspathEntry) rootPathToResolvedEntries.get(getPath());
		567	}
		568	if (resolvedEntry == null) {
		569	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_NOT_ON_CLASSPATH, this));
		570	}
		571	return resolvedEntry;
		572	}
557		573
558		574
559	public IResource resource() {	575	public IResource resource() {

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/internal/core/SetClasspathOperation.java (-2 / +14 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 30-50 Link Here
30	public class SetClasspathOperation extends ChangeClasspathOperation {	30	public class SetClasspathOperation extends ChangeClasspathOperation {
31		31
32	IClasspathEntry[] newRawClasspath;	32	IClasspathEntry[] newRawClasspath;
		33	IClasspathEntry[] referencedEntries;
33	IPath newOutputLocation;	34	IPath newOutputLocation;
34	JavaProject project;	35	JavaProject project;
35		36
		37	public SetClasspathOperation(
		38	JavaProject project,
		39	IClasspathEntry[] newRawClasspath,
		40	IPath newOutputLocation,
		41	boolean canChangeResource) {
		42
		43	this(project, newRawClasspath, null, newOutputLocation, canChangeResource);
		44	}
		45
36	/**	46	/**
37	* When executed, this operation sets the raw classpath and output location of the given project.	47	* When executed, this operation sets the raw classpath and output location of the given project.
38	*/	48	*/
39	public SetClasspathOperation(	49	public SetClasspathOperation(
40	JavaProject project,	50	JavaProject project,
41	IClasspathEntry[] newRawClasspath,	51	IClasspathEntry[] newRawClasspath,
		52	IClasspathEntry[] referencedEntries,
42	IPath newOutputLocation,	53	IPath newOutputLocation,
43	boolean canChangeResource) {	54	boolean canChangeResource) {
44		55
45	super(new IJavaElement[] { project }, canChangeResource);	56	super(new IJavaElement[] { project }, canChangeResource);
46	this.project = project;	57	this.project = project;
47	this.newRawClasspath = newRawClasspath;	58	this.newRawClasspath = newRawClasspath;
		59	this.referencedEntries = referencedEntries;
48	this.newOutputLocation = newOutputLocation;	60	this.newOutputLocation = newOutputLocation;
49	}	61	}
50		62
Lines 56-62 Link Here
56	try {	68	try {
57	// set raw classpath and null out resolved info	69	// set raw classpath and null out resolved info
58	PerProjectInfo perProjectInfo = this.project.getPerProjectInfo();	70	PerProjectInfo perProjectInfo = this.project.getPerProjectInfo();
59	ClasspathChange classpathChange = perProjectInfo.setRawClasspath(this.newRawClasspath, this.newOutputLocation, JavaModelStatus.VERIFIED_OK/format is ok/);	71	ClasspathChange classpathChange = perProjectInfo.setRawClasspath(this.newRawClasspath, this.referencedEntries, this.newOutputLocation, JavaModelStatus.VERIFIED_OK/format is ok/);
60		72
61	// if needed, generate delta, update project ref, create markers, ...	73	// if needed, generate delta, update project ref, create markers, ...
62	classpathChanged(classpathChange);	74	classpathChanged(classpathChange);

Lines 88-95 Link Here

(-)src/org/eclipse/jdt/core/tests/model/ClasspathTests.java (-2 / +313 lines)
88	// All specified tests which do not belong to the class are skipped...	88	// All specified tests which do not belong to the class are skipped...
89	static {	89	static {
90	// Names of tests to run: can be "testBugXXXX" or "BugXXXX")	90	// Names of tests to run: can be "testBugXXXX" or "BugXXXX")
91	// TESTS_PREFIX = "testClasspathDuplicateExtraAttribute";	91	// TESTS_PREFIX = "testBug252341c";
92	// TESTS_NAMES = new String[] {"testClasspathValidation42"};	92	// TESTS_NAMES = new String[] {"testClasspathWithNonExistentLibraryEntry"};
93	// TESTS_NUMBERS = new int[] { 23, 28, 38 };	93	// TESTS_NUMBERS = new int[] { 23, 28, 38 };
94	// TESTS_RANGE = new int[] { 21, 38 };	94	// TESTS_RANGE = new int[] { 21, 38 };
95	}	95	}
Lines 6116-6120 Link Here
6116	deleteExternalResource("lib.jar");	6116	deleteExternalResource("lib.jar");
6117	}	6117	}
6118	}	6118	}
		6119	/**
		6120	* @bug 252431:New API is needed to better identify referenced jars in the Class-Path: entry
		6121	* Test that 1) referenced libraries are added to the resolved classpath in the right order
		6122	* 2) referenced libraries are added to the appropriate referencing library in the correct order
		6123	* 3) referenced libraries and top-level libraries retain the source attachment and source attachment root path
		6124	* 4) referenced libraries point to the correct entry as their referencingEntry.
		6125	* 5) referenced libraries and their attributes are persisted in the .classpath file
		6126	*
		6127	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=252431"
		6128	* @throws Exception
		6129	*/
		6130	public void testBug252341a() throws Exception {
		6131	try {
		6132	IJavaProject p = createJavaProject("P");
		6133	addLibrary(p, "lib1.jar", "abc.zip", new String[0],
		6134	new String[] {
		6135	"META-INF/MANIFEST.MF",
		6136	"Manifest-Version: 1.0\n" +
		6137	"Class-Path: lib2.jar lib3.jar\n",
		6138	},
		6139	JavaCore.VERSION_1_4);
		6140	createFile("/P/lib2.jar", "");
		6141	createFile("/P/lib3.jar", "");
		6142
		6143	// Test referenced entries are included in the right order in the resolved classpath
		6144	IClasspathEntry[] resolvedClasspath = p.getResolvedClasspath(true);
		6145	assertClasspathEquals(resolvedClasspath,
		6146	"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" +
		6147	""+ getExternalJCLPathString() + "[CPE_LIBRARY][K_BINARY][isExported:false]\n" +
		6148	"/P/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
		6149	"/P/lib3.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
		6150	"/P/lib1.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/abc.zip][isExported:true]");
		6151
		6152	IClasspathEntry[] rawClasspath = p.getRawClasspath();
		6153	assertClasspathEquals(rawClasspath,
		6154	"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" +
		6155	"JCL_LIB[CPE_VARIABLE][K_SOURCE][isExported:false]\n" +
		6156	"/P/lib1.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/abc.zip][isExported:true]");
		6157
		6158	// Test referenced entries for a particular entry appear in the right order and the referencingEntry
		6159	// attribute has the correct value
		6160	IClasspathEntry[] chains = JavaCore.getReferencedClasspathEntries(rawClasspath[2], p);
		6161	assertClasspathEquals(chains,
		6162	"/P/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
		6163	"/P/lib3.jar[CPE_LIBRARY][K_BINARY][isExported:true]");
		6164
		6165	assertSame("Referencing Entry", rawClasspath[2], chains[0].getReferencingEntry());
		6166	assertSame("Referencing Entry", rawClasspath[2], chains[1].getReferencingEntry());
		6167
		6168	// Test a newly created library entry with similar attributes but without any referencing entry is equal to
		6169	// the original referenced entry
		6170	IClasspathEntry tempLibEntry = JavaCore.newLibraryEntry(chains[0].getPath(), chains[0].getSourceAttachmentPath(), chains[0].getSourceAttachmentRootPath(), true);
		6171	assertEquals("Library Entry", tempLibEntry, chains[0]);
		6172
		6173	// Test the source attachment and other attributes added to the referenced entries are stored and retrieved properly
		6174	assertEquals("source attachment", resolvedClasspath[4].getSourceAttachmentPath().toPortableString(), "/P/abc.zip");
		6175	assertNull("source attachment", chains[0].getSourceAttachmentPath());
		6176	assertNull("source attachment", chains[1].getSourceAttachmentPath());
		6177	assertNull("source attachment root", chains[0].getSourceAttachmentRootPath());
		6178	assertNull("source attachment root", chains[1].getSourceAttachmentRootPath());
		6179
		6180	((ClasspathEntry)chains[0]).sourceAttachmentPath = new Path("/P/efg.zip");
		6181	((ClasspathEntry)chains[1]).sourceAttachmentPath = new Path("/P/xyz.zip");
		6182	((ClasspathEntry)chains[0]).sourceAttachmentRootPath = new Path("/src2");
6183	((ClasspathEntry)chains[1]).sourceAttachmentRootPath = new Path("/src3");
6184
6185	IClasspathAttribute javadocLoc = JavaCore.newClasspathAttribute("javadoc_location", "/P/efg.zip");
6186	((ClasspathEntry)chains[0]).extraAttributes = new IClasspathAttribute[]{javadocLoc};
6187
6188	p.setRawClasspath(rawClasspath, chains, p.getOutputLocation(), null);
6189
6190	// Test the .classpath file contains all the referenced entries and their attributes
6191	String contents = new String (org.eclipse.jdt.internal.core.util.Util.getResourceContentsAsCharArray(getFile("/P/.classpath")));
6192	assertSourceEquals(
6193	"Unexpected content",
6194	"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
6195	"<classpath>\n" +
6196	" <classpathentry kind=\"src\" path=\"\"/>\n" +
6197	" <classpathentry kind=\"var\" path=\"JCL_LIB\"/>\n" +
6198	" <classpathentry exported=\"true\" kind=\"lib\" path=\"lib1.jar\" sourcepath=\"abc.zip\"/>\n" +
6199	" <classpathentry kind=\"output\" path=\"\"/>\n" +
6200	" <referencedentry exported=\"true\" kind=\"lib\" path=\"lib2.jar\" rootpath=\"/src2\" sourcepath=\"efg.zip\">\n" +
6201	" <attributes>\n" +
6202	" <attribute name=\"javadoc_location\" value=\"/P/efg.zip\"/>\n" +
6203	" </attributes>\n" +
6204	" </referencedentry>\n" +
6205	" <referencedentry exported=\"true\" kind=\"lib\" path=\"lib3.jar\" rootpath=\"/src3\" sourcepath=\"xyz.zip\"/>\n" +
6206	"</classpath>\n",
6207	contents);
6208
6209	p.close();
6210	p.open(null);
6211	rawClasspath = p.getRawClasspath();
6212	resolvedClasspath = p.getResolvedClasspath(true);
6213
6214	assertClasspathEquals(rawClasspath,
6215	"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" +
6216	"JCL_LIB[CPE_VARIABLE][K_SOURCE][isExported:false]\n" +
6217	"/P/lib1.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/abc.zip][isExported:true]");
6218
6219	assertClasspathEquals(resolvedClasspath,
6220	"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" +
6221	""+ getExternalJCLPathString() + "[CPE_LIBRARY][K_BINARY][isExported:false]\n" +
6222	"/P/lib2.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/efg.zip][rootPath:/src2][isExported:true][attributes:javadoc_location=/P/efg.zip]\n" +
6223	"/P/lib3.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/xyz.zip][rootPath:/src3][isExported:true]\n" +
6224	"/P/lib1.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/abc.zip][isExported:true]");
6225
6226	} finally {
6227	deleteProject("P");
6228	}
6229	}
6230	/**
6231	* Additional tests for bug 252431.
6232	* When multiple libraries have one or more common referenced library in their MANIFEST
6233	* 1) The common referenced libries are added to the first library entry in the raw classpath
6234	* 2) Removing one of the top-level library from the raw classpath doesn't remove the referenced
6235	* entry that was commonly referenced by another entry and the referenced entry's source
6236	* attachment and other attributes are retained.
6237	* 3) Passing a NULL referencedEntries array retains the referenced entries
6238	* 4) Passing an empty array as referencedEntries clears the earlier referenced entries
6239	*
6240	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=252431"
6241	* @throws Exception
6242	*/
6243	public void testBug252341b() throws Exception {
6244	try {
6245	IJavaProject p = createJavaProject("P");
6246	addLibrary(p, "lib1.jar", null, new String[0],
6247	new String[] {
6248	"META-INF/MANIFEST.MF",
6249	"Manifest-Version: 1.0\n" +
6250	"Class-Path: lib3.jar lib4.jar\n",
6251	},
6252	JavaCore.VERSION_1_4);
6253
6254	addLibrary(p, "lib2.jar", null, new String[0],
6255	new String[] {
6256	"META-INF/MANIFEST.MF",
6257	"Manifest-Version: 1.0\n" +
6258	"Class-Path: lib3.jar lib5.jar\n",
6259	},
6260	JavaCore.VERSION_1_4);
6261	createFile("/P/lib3.jar", "");
6262	createFile("/P/lib4.jar", "");
6263	createFile("/P/lib5.jar", "");
6264
6265	// Test that the referenced entries are not included in the raw classpath
6266	IClasspathEntry[] rawClasspath = p.getRawClasspath();
6267	assertClasspathEquals(
6268	rawClasspath,
6269	"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" +
6270	"JCL_LIB[CPE_VARIABLE][K_SOURCE][isExported:false]\n" +
6271	"/P/lib1.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
6272	"/P/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:true]");
6273
6274	IClasspathEntry[] rawEntries = new IClasspathEntry[2];
6275	rawEntries[0] = JavaCore.newLibraryEntry(new Path("/P/lib1.jar"), null, null, true);
6276	rawEntries[1] = JavaCore.newLibraryEntry(new Path("/P/lib2.jar"), null, null, true);
6277
6278	// Test that the referenced entries are included in the raw classpath and in the right order
6279	IClasspathEntry[] resolvedClasspath = p.getResolvedClasspath(true);
6280	assertClasspathEquals(resolvedClasspath,
6281	"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" +
6282	""+ getExternalJCLPathString() + "[CPE_LIBRARY][K_BINARY][isExported:false]\n" +
6283	"/P/lib3.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
6284	"/P/lib4.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
6285	"/P/lib1.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
6286	"/P/lib5.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
6287	"/P/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:true]");
6288
6289	// Test that the referenced classpath entries has the appropriate referencingEntry value
6290	IClasspathEntry[] chains = JavaCore.getReferencedClasspathEntries(rawEntries[0], p);
6291	assertClasspathEquals(
6292	chains,
6293	"/P/lib3.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
6294	"/P/lib4.jar[CPE_LIBRARY][K_BINARY][isExported:true]");
6295	assertEquals("Referencing Entry" , rawEntries[0], chains[0].getReferencingEntry());
6296	assertEquals("Referencing Entry" , rawEntries[0], chains[1].getReferencingEntry());
6297
6298	chains = JavaCore.getReferencedClasspathEntries(rawEntries[1], p);
6299	assertClasspathEquals(
6300	chains,
6301	"/P/lib3.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
6302	"/P/lib5.jar[CPE_LIBRARY][K_BINARY][isExported:true]");
6303
6304	assertEquals("Referencing Entry" , rawEntries[0], chains[0].getReferencingEntry());
6305	assertEquals("Referencing Entry" , rawEntries[1], chains[1].getReferencingEntry());
6306
6307	// // Test IPackageFragmentRoot#getResolvedClasspathEntry
6308	IPackageFragmentRoot[] roots = p.getPackageFragmentRoots();
6309	assertEquals("Package fragment root", roots[2].getResolvedClasspathEntry(), resolvedClasspath[2]);
6310	assertEquals("Package fragment root", roots[3].getResolvedClasspathEntry(), resolvedClasspath[3]);
6311	assertEquals("Package fragment root", roots[4].getResolvedClasspathEntry(), resolvedClasspath[4]);
6312	assertEquals("Package fragment root", roots[5].getResolvedClasspathEntry(), resolvedClasspath[5]);
6313	assertEquals("Package fragment root", roots[6].getResolvedClasspathEntry(), resolvedClasspath[6]);
6314
6315	// Test the attributes added to the referenced classpath entries are stored and retrieved properly
6316	((ClasspathEntry)chains[0]).sourceAttachmentPath = new Path("/P/efg.zip");
6317	((ClasspathEntry)chains[1]).sourceAttachmentPath = new Path("/P/xyz.zip");
6318	((ClasspathEntry)chains[0]).sourceAttachmentRootPath = new Path("/src2");
6319	((ClasspathEntry)chains[1]).sourceAttachmentRootPath = new Path("/src3");
6320
6321	IClasspathAttribute javadocLoc = JavaCore.newClasspathAttribute("javadoc_location", "/P/efg.zip");
6322	((ClasspathEntry)chains[0]).extraAttributes = new IClasspathAttribute[]{javadocLoc};
6323
6324	p.setRawClasspath(rawClasspath, chains, p.getOutputLocation(), null);
6325	resolvedClasspath = p.getResolvedClasspath(true);
6326
6327	assertClasspathEquals(resolvedClasspath,
6328	"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" +
6329	""+ getExternalJCLPathString() + "[CPE_LIBRARY][K_BINARY][isExported:false]\n" +
6330	"/P/lib3.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/efg.zip][rootPath:/src2][isExported:true][attributes:javadoc_location=/P/efg.zip]\n" +
6331	"/P/lib4.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
6332	"/P/lib1.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
6333	"/P/lib5.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/xyz.zip][rootPath:/src3][isExported:true]\n" +
6334	"/P/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:true]");
6335
6336	// Test that removing any of the referencing entry from the raw classpath has the correct effect
6337	// on the resolved classpath. Also test passing referencedEntries = null retains the existing
6338	// referenced entries
6339	IClasspathEntry[] newRawClasspath = new IClasspathEntry[rawClasspath.length-1];
6340	System.arraycopy(rawClasspath, 0, newRawClasspath, 0, 2);
6341	System.arraycopy(rawClasspath, 3, newRawClasspath, 2, 1);
6342	p.setRawClasspath(newRawClasspath, null, p.getOutputLocation(), null);
6343	resolvedClasspath = p.getResolvedClasspath(true);
6344	assertClasspathEquals(resolvedClasspath,
6345	"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" +
6346	""+ getExternalJCLPathString() + "[CPE_LIBRARY][K_BINARY][isExported:false]\n" +
6347	"/P/lib3.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/efg.zip][rootPath:/src2][isExported:true][attributes:javadoc_location=/P/efg.zip]\n" +
6348	"/P/lib5.jar[CPE_LIBRARY][K_BINARY][sourcePath:/P/xyz.zip][rootPath:/src3][isExported:true]\n" +
6349	"/P/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:true]");
6350
6351	// Test that passing empty array of referencedEntries clears all the earlier ones.
6352	p.setRawClasspath(newRawClasspath, new IClasspathEntry[]{}, p.getOutputLocation(), null);
6353	resolvedClasspath = p.getResolvedClasspath(true);
6354	assertClasspathEquals(resolvedClasspath,
6355	"/P[CPE_SOURCE][K_SOURCE][isExported:false]\n" +
6356	""+ getExternalJCLPathString() + "[CPE_LIBRARY][K_BINARY][isExported:false]\n" +
6357	"/P/lib3.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
6358	"/P/lib5.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
6359	"/P/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:true]");
6360
6361	} finally {
6362	deleteProject("P");
6363	}
6364	}
6365	/**
6366	* Additional tests for bug 252431.
6367	* Test that duplicate referenced entries or entries that are already present in the raw classpath
6368	* are excluded from the referenced entries when invoking
6369	* {@link IJavaProject#setRawClasspath(IClasspathEntry[], IClasspathEntry[], IPath, IProgressMonitor)}
6370	*
6371	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=252431"
6372	* @throws Exception
6373	*/
6374	public void testBug252341c() throws Exception {
6375	try {
6376	IJavaProject p = createJavaProject("P");
6377	addLibrary(p, "lib1.jar", null, new String[0],
6378	new String[] {
6379	"META-INF/MANIFEST.MF",
6380	"Manifest-Version: 1.0\n" +
6381	"Class-Path: lib3.jar lib4.jar\n",
6382	},
6383	JavaCore.VERSION_1_4);
6384
6385	addLibrary(p, "lib2.jar", null, new String[0],
6386	new String[] {
6387	"META-INF/MANIFEST.MF",
6388	"Manifest-Version: 1.0\n" +
6389	"Class-Path: lib3.jar lib5.jar\n",
6390	},
6391	JavaCore.VERSION_1_4);
6392	createFile("/P/lib3.jar", "");
6393	createFile("/P/lib4.jar", "");
6394	createFile("/P/lib5.jar", "");
6395
6396	IClasspathEntry[] rawClasspath = p.getRawClasspath();
6397
6398	IClasspathEntry[] rawEntries = new IClasspathEntry[2];
6399	rawEntries[0] = JavaCore.newLibraryEntry(new Path("/P/lib1.jar"), null, null, true);
6400	rawEntries[1] = JavaCore.newLibraryEntry(new Path("/P/lib2.jar"), null, null, true);
6401
6402	// Test that the referenced classpath entries has the appropriate referencingEntry value
6403	IClasspathEntry[] chains = JavaCore.getReferencedClasspathEntries(rawEntries[0], p);
6404
6405	IClasspathEntry[] referencedEntries = new IClasspathEntry[5];
6406	referencedEntries[0] = chains[0];
6407	referencedEntries[1] = chains[1];
6408
6409	chains = JavaCore.getReferencedClasspathEntries(rawEntries[1], p);
6410
6411	referencedEntries[2] = chains[0];
6412	referencedEntries[3] = chains[1];
6413	referencedEntries[4] = chains[1];
6414
6415	p.setRawClasspath(rawClasspath, referencedEntries, p.getOutputLocation(), null);
6416
6417	p.close();
6418	p.open(null);
6419
6420	IClasspathEntry[] storedReferencedEnties = p.getReferencedClasspathEntries();
6421	assertClasspathEquals(storedReferencedEnties,
6422	"/P/lib3.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
6423	"/P/lib4.jar[CPE_LIBRARY][K_BINARY][isExported:true]\n" +
6424	"/P/lib5.jar[CPE_LIBRARY][K_BINARY][isExported:true]");
6425	}
6426	finally {
6427	deleteProject("P");
6428	}
6429	}
6119		6430
6120	}	6431	}