Attachment #55963 for bug #168671

View | Details | Raw Unified | Return to bug 168671
Collapse All | Expand All




		}
		return -1;
	}
	/**
	 * Returns whether the local file system supports accessing and modifying
	 * the given attribute.
	 */
	protected static boolean isAttributeSupported(int attribute) {
		return (EFS.getLocalFileSystem().attributes() & attribute) != 0;
	}
	
	/**
	 * Returns whether the given resource is read-only or not.
	 * @param resource
	 * @return <code>true</code> if the resource is read-only, <code>false</code> if it is not or
	 * 	if the file system does not support the read-only attribute.
	 */
	public static boolean isReadOnly(IResource resource) {
		if (isReadOnlySupported()) {
			ResourceAttributes resourceAttributes = resource.getResourceAttributes();
			if (resourceAttributes == null) return false; // not supported on this platform for this resource
			return resourceAttributes.isReadOnly();
		}
		return false;
	}

	/**
	 * Returns whether the local file system supports accessing and modifying
	 * the read only flag.
	 */
	public static boolean isReadOnlySupported() {
		return isAttributeSupported(EFS.ATTRIBUTE_READ_ONLY);
	}

	/*
	 * Returns whether the given java element is exluded from its root's classpath.

		split[currentWord] = string.substring(last, end);
		return split;
	}
	/**
	 * Sets or unsets the given resource as read-only in the file system.
	 * It's a no-op if the file system does not support the read-only attribute.
	 * 
	 * @param resource The resource to set as read-only
	 * @param readOnly <code>true</code> to set it to read-only, 
	 *		<code>false</code> to unset
	 */
	public static void setReadOnly(IResource resource, boolean readOnly) {
		if (isReadOnlySupported()) {
			ResourceAttributes resourceAttributes = resource.getResourceAttributes();
			if (resourceAttributes == null) return; // not supported on this platform for this resource
			resourceAttributes.setReadOnly(readOnly);
			try {
				resource.setResourceAttributes(resourceAttributes);
			} catch (CoreException e) {
				// ignore
			}
		}
	}
	public static void sort(char[][] list) {




package org.eclipse.jdt.core.tests.model;

import org.eclipse.core.resources.*;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFileModificationValidator;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.*;
import org.eclipse.jdt.internal.core.util.Util;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.team.core.RepositoryProvider;

/**

	}

	public void setReadOnly(IResource resource, boolean readOnly) throws CoreException {
		if (Util.isReadOnlySupported()) {
			ResourceAttributes resourceAttributes = resource.getResourceAttributes();
			if (resourceAttributes != null) {
				resourceAttributes.setReadOnly(readOnly);
				resource.setResourceAttributes(resourceAttributes);
			}		

	public boolean isReadOnly(IResource resource) throws CoreException {
		ResourceAttributes resourceAttributes = resource.getResourceAttributes();
		if (resourceAttributes != null) {
			return resourceAttributes.isReadOnly();
		}
		return false;
	}
}




import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.runtime.*;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.internal.core.util.Util;
import org.eclipse.team.core.RepositoryProvider;



 * Ensures that one cannot commit the contents of a working copy on a read only cu. 
 */
public void testChangeContentOfReadOnlyCU1() throws CoreException {
	if (!Util.isReadOnlySupported()) {
		// Do not test if file system does not support read-only attribute
		return;
	}
	IResource resource = this.cu.getUnderlyingResource();
	boolean readOnlyFlag = Util.isReadOnly(resource);
	boolean didComplain = false;
	try {
		Util.setReadOnly(resource, true);
		this.copy.getBuffer().setContents("invalid");
		this.copy.commitWorkingCopy(true, null);
	} catch(JavaModelException e){
		didComplain = true;
	} finally {
		Util.setReadOnly(resource, readOnlyFlag);
	}
	assertTrue("Should have complained about modifying a read-only unit:", didComplain);
	assertTrue("ReadOnly buffer got modified:", !this.cu.getBuffer().getContents().equals("invalid"));

 * provider allows it. 
 */
public void testChangeContentOfReadOnlyCU2() throws CoreException {
	if (!Util.isReadOnlySupported()) {
		// Do not test if file system does not support read-only attribute
		return;
	}
	String newContents =
		"package x.y;\n" +
		"public class A {\n" +

		"}";
	IResource resource = this.cu.getUnderlyingResource();
	IProject project = resource.getProject();
	boolean readOnlyFlag = Util.isReadOnly(resource);
	try {
		RepositoryProvider.map(project, TestPessimisticProvider.NATURE_ID);
		TestPessimisticProvider.markWritableOnSave = true;
		Util.setReadOnly(resource, true);
		
		this.copy.getBuffer().setContents(newContents);
		this.copy.commitWorkingCopy(true, null);

	} finally {
		TestPessimisticProvider.markWritableOnSave = false;
		RepositoryProvider.unmap(project);
		Util.setReadOnly(resource, readOnlyFlag);
	}
}





import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.internal.core.util.Util;

public class CopyMoveResourcesTests extends CopyMoveTests {
/**

			"public class X {\n" +
			"}"
		);
		Util.setReadOnly(file, true);
		ICompilationUnit cuSource = getCompilationUnit("/P/src/p1/X.java");
	
		this.createFolder("/P/src/p2");

		assertTrue("Destination cu should be read-only", file2.isReadOnly());
	} finally {
		if (file != null) {
			Util.setReadOnly(file, false);
		}
		if (file2 != null) {
			Util.setReadOnly(file2, false);
		}
		deleteFolder("/P/src/p1");
		deleteFolder("/P/src/p2");

 * Ensures that a package fragment can be copied to a different package fragment root.
 */
public void testCopyReadOnlyPackageFragment() throws CoreException {
	if (!Util.isReadOnlySupported()) {
		// Do not test if file system does not support read-only attribute
		return;
	}
	IPackageFragment pkgSource = null;
	IPackageFragment pkg2 = null;
	try {

			"public class X {\n" +
			"}"
		);
		Util.setReadOnly(getFile("/P/src/p1/p2/p3/X.java"), true);
		pkgSource = getPackage("/P/src/p1");
		Util.setReadOnly(pkgSource.getResource(), true);
		pkg2 = getPackage("/P/src/p1/p2/p3");
		Util.setReadOnly(pkg2.getResource(), true);
	
		IPackageFragmentRoot rootDest= getPackageFragmentRoot("P", "src2");
	
		copyPositive(pkg2, rootDest, null, null, false);
		
		assertTrue("Not readOnly", Util.isReadOnly(getPackage("/P/src2/p1").getResource()));
		assertTrue("Is readOnly", !Util.isReadOnly(getPackage("/P/src2/p1/p2").getResource()));
		assertTrue("Not readOnly", Util.isReadOnly(getPackage("/P/src2/p1/p2/p3").getResource()));
		assertTrue("Is readOnly", Util.isReadOnly(getFile("/P/src2/p1/p2/p3/X.java")));
	} finally {
		IFile xSrcFile = getFile("/P/src/p1/p2/p3/X.java");
		if (xSrcFile != null) {
			Util.setReadOnly(xSrcFile, false);
		}
		if (pkg2 != null) {
			Util.setReadOnly(pkg2.getResource(), false);
		}
		if (pkgSource != null) {
			Util.setReadOnly(pkgSource.getResource(), false);
		}
		IPackageFragment p1Fragment = getPackage("/P/src2/p1");
		if (p1Fragment != null) {
			Util.setReadOnly(p1Fragment.getResource(), false);
		}
		IPackageFragment p3Fragment = getPackage("/P/src2/p1/p2/p3");
		if (p3Fragment != null) {
			Util.setReadOnly(p3Fragment.getResource(), false);
		}
		IFile xFile = getFile("/P/src2/p1/p2/p3/X.java");
		if (xFile != null) {
			Util.setReadOnly(xFile, false);
		}
		deleteFolder("/P/src/p1");
	}

 * Ensures that a package fragment can be copied to a different package fragment root.
 */
public void testMoveReadOnlyPackageFragment() throws CoreException {
	if (!Util.isReadOnlySupported()) {
		// Do not test if file system does not support read-only attribute
		return;
	}
	IPackageFragment pkgSource = null;
	IPackageFragment pkg2 = null;
	try {

			"public class X {\n" +
			"}"
		);
		Util.setReadOnly(getFile("/P/src/p1/p2/p3/X.java"), true);
		pkgSource = getPackage("/P/src/p1");
		Util.setReadOnly(pkgSource.getResource(), true);
		pkg2 = getPackage("/P/src/p1/p2/p3");
		Util.setReadOnly(pkg2.getResource(), true);
	
		IPackageFragmentRoot rootDest= getPackageFragmentRoot("P", "src2");
	
		movePositive(pkg2, rootDest, null, null, false);
		
		assertTrue("Not readOnly", Util.isReadOnly(getPackage("/P/src2/p1").getResource()));
		assertTrue("Is readOnly", !Util.isReadOnly(getPackage("/P/src2/p1/p2").getResource()));
		assertTrue("Not readOnly", Util.isReadOnly(getPackage("/P/src2/p1/p2/p3").getResource()));
		assertTrue("Is readOnly", Util.isReadOnly(getFile("/P/src2/p1/p2/p3/X.java")));
	} finally {
		IFile xSrcFile = getFile("/P/src/p1/p2/p3/X.java");
		if (xSrcFile != null) {
			Util.setReadOnly(xSrcFile, false);
		}
		if (pkg2 != null) {
			Util.setReadOnly(pkg2.getResource(), false);
		}
		if (pkgSource != null) {
			Util.setReadOnly(pkgSource.getResource(), false);
		}
		IPackageFragment p1Fragment = getPackage("/P/src2/p1");
		if (p1Fragment != null) {
			Util.setReadOnly(p1Fragment.getResource(), false);
		}
		IPackageFragment p3Fragment = getPackage("/P/src2/p1/p2/p3");
		if (p3Fragment != null) {
			Util.setReadOnly(p3Fragment.getResource(), false);
		}
		IFile xFile = getFile("/P/src2/p1/p2/p3/X.java");
		if (xFile != null) {
			Util.setReadOnly(xFile, false);
		}
		deleteFolder("/P/src/p1");
	}




		return JavaCore.newSourceEntry(folderPath, accessibleFiles, nonAccessibleFiles, null); 
	}
}
public void setReadOnly(IResource resource, boolean readOnly) throws CoreException {
	ResourceAttributes resourceAttributes = resource.getResourceAttributes();
	if (resourceAttributes != null) {
		resourceAttributes.setReadOnly(readOnly);
		resource.setResourceAttributes(resourceAttributes);
	}		
}

public boolean isReadOnly(IResource resource) throws CoreException {
	ResourceAttributes resourceAttributes = resource.getResourceAttributes();
	if (resourceAttributes != null) {
		return resourceAttributes.isReadOnly();
	}
	return false;
}
}

Return to bug 168671

Lines 1221-1226 Link Here

(-)model/org/eclipse/jdt/internal/core/util/Util.java (-12 / +47 lines)
1221	}	1221	}
1222	return -1;	1222	return -1;
1223	}	1223	}
		1224	/**
		1225	* Returns whether the local file system supports accessing and modifying
		1226	* the given attribute.
		1227	*/
		1228	protected static boolean isAttributeSupported(int attribute) {
		1229	return (EFS.getLocalFileSystem().attributes() & attribute) != 0;
		1230	}
		1231
		1232	/**
		1233	* Returns whether the given resource is read-only or not.
		1234	* @param resource
		1235	* @return <code>true</code> if the resource is read-only, <code>false</code> if it is not or
		1236	* if the file system does not support the read-only attribute.
		1237	*/
		1238	public static boolean isReadOnly(IResource resource) {
		1239	if (isReadOnlySupported()) {
		1240	ResourceAttributes resourceAttributes = resource.getResourceAttributes();
		1241	if (resourceAttributes == null) return false; // not supported on this platform for this resource
		1242	return resourceAttributes.isReadOnly();
		1243	}
		1244	return false;
		1245	}
		1246
		1247	/**
		1248	* Returns whether the local file system supports accessing and modifying
		1249	* the read only flag.
		1250	*/
		1251	public static boolean isReadOnlySupported() {
		1252	return isAttributeSupported(EFS.ATTRIBUTE_READ_ONLY);
		1253	}
1224		1254
1225	/*	1255	/*
1226	* Returns whether the given java element is exluded from its root's classpath.	1256	* Returns whether the given java element is exluded from its root's classpath.
Lines 1832-1850 Link Here
1832	split[currentWord] = string.substring(last, end);	1862	split[currentWord] = string.substring(last, end);
1833	return split;	1863	return split;
1834	}	1864	}
1835	public static boolean isReadOnly(IResource resource) {	1865	/**
1836	ResourceAttributes resourceAttributes = resource.getResourceAttributes();	1866	* Sets or unsets the given resource as read-only in the file system.
1837	if (resourceAttributes == null) return false; // not supported on this platform for this resource	1867	* It's a no-op if the file system does not support the read-only attribute.
1838	return resourceAttributes.isReadOnly();	1868	*
1839	}	1869	* @param resource The resource to set as read-only
		1870	* @param readOnly <code>true</code> to set it to read-only,
		1871	* <code>false</code> to unset
		1872	*/
1840	public static void setReadOnly(IResource resource, boolean readOnly) {	1873	public static void setReadOnly(IResource resource, boolean readOnly) {
1841	ResourceAttributes resourceAttributes = resource.getResourceAttributes();	1874	if (isReadOnlySupported()) {
1842	if (resourceAttributes == null) return; // not supported on this platform for this resource	1875	ResourceAttributes resourceAttributes = resource.getResourceAttributes();
1843	resourceAttributes.setReadOnly(readOnly);	1876	if (resourceAttributes == null) return; // not supported on this platform for this resource
1844	try {	1877	resourceAttributes.setReadOnly(readOnly);
1845	resource.setResourceAttributes(resourceAttributes);	1878	try {
1846	} catch (CoreException e) {	1879	resource.setResourceAttributes(resourceAttributes);
1847	// ignore	1880	} catch (CoreException e) {
		1881	// ignore
		1882	}
1848	}	1883	}
1849	}	1884	}
1850	public static void sort(char[][] list) {	1885	public static void sort(char[][] list) {

Lines 11-23 Link Here

(-)src/org/eclipse/jdt/core/tests/model/TestPessimisticProvider.java (-18 / +7 lines)
11	package org.eclipse.jdt.core.tests.model;	11	package org.eclipse.jdt.core.tests.model;
12		12
13	import org.eclipse.core.resources.*;	13	import org.eclipse.core.resources.*;
14	import org.eclipse.core.resources.IFile;
15	import org.eclipse.core.resources.IFileModificationValidator;
16	import org.eclipse.core.resources.ResourcesPlugin;
17	import org.eclipse.core.runtime.*;	14	import org.eclipse.core.runtime.*;
18	import org.eclipse.core.runtime.CoreException;	15	import org.eclipse.jdt.internal.core.util.Util;
19	import org.eclipse.core.runtime.IStatus;
20	import org.eclipse.core.runtime.Status;
21	import org.eclipse.team.core.RepositoryProvider;	16	import org.eclipse.team.core.RepositoryProvider;
22		17
23	/**	18	/**
Lines 89-106 Link Here
89	}	84	}
90		85
91	public void setReadOnly(IResource resource, boolean readOnly) throws CoreException {	86	public void setReadOnly(IResource resource, boolean readOnly) throws CoreException {
92	ResourceAttributes resourceAttributes = resource.getResourceAttributes();	87	if (Util.isReadOnlySupported()) {
93	if (resourceAttributes != null) {	88	ResourceAttributes resourceAttributes = resource.getResourceAttributes();
94	resourceAttributes.setReadOnly(readOnly);	89	if (resourceAttributes != null) {
95	resource.setResourceAttributes(resourceAttributes);	90	resourceAttributes.setReadOnly(readOnly);
96	}	91	resource.setResourceAttributes(resourceAttributes);
97	}	92	}
98
99	public boolean isReadOnly(IResource resource) throws CoreException {
100	ResourceAttributes resourceAttributes = resource.getResourceAttributes();
101	if (resourceAttributes != null) {
102	return resourceAttributes.isReadOnly();
103	}	93	}
104	return false;
105	}	94	}
106	}	95	}

Lines 20-25 Link Here

(-)src/org/eclipse/jdt/core/tests/model/WorkingCopyTests.java (-6 / +15 lines)
20	import org.eclipse.core.resources.IWorkspaceRunnable;	20	import org.eclipse.core.resources.IWorkspaceRunnable;
21	import org.eclipse.core.runtime.*;	21	import org.eclipse.core.runtime.*;
22	import org.eclipse.jdt.core.*;	22	import org.eclipse.jdt.core.*;
		23	import org.eclipse.jdt.internal.core.util.Util;
23	import org.eclipse.team.core.RepositoryProvider;	24	import org.eclipse.team.core.RepositoryProvider;
24		25
25		26
Lines 131-147 Link Here
131	* Ensures that one cannot commit the contents of a working copy on a read only cu.	132	* Ensures that one cannot commit the contents of a working copy on a read only cu.
132	*/	133	*/
133	public void testChangeContentOfReadOnlyCU1() throws CoreException {	134	public void testChangeContentOfReadOnlyCU1() throws CoreException {
		135	if (!Util.isReadOnlySupported()) {
		136	// Do not test if file system does not support read-only attribute
		137	return;
		138	}
134	IResource resource = this.cu.getUnderlyingResource();	139	IResource resource = this.cu.getUnderlyingResource();
135	boolean readOnlyFlag = isReadOnly(resource);	140	boolean readOnlyFlag = Util.isReadOnly(resource);
136	boolean didComplain = false;	141	boolean didComplain = false;
137	try {	142	try {
138	setReadOnly(resource, true);	143	Util.setReadOnly(resource, true);
139	this.copy.getBuffer().setContents("invalid");	144	this.copy.getBuffer().setContents("invalid");
140	this.copy.commitWorkingCopy(true, null);	145	this.copy.commitWorkingCopy(true, null);
141	} catch(JavaModelException e){	146	} catch(JavaModelException e){
142	didComplain = true;	147	didComplain = true;
143	} finally {	148	} finally {
144	setReadOnly(resource, readOnlyFlag);	149	Util.setReadOnly(resource, readOnlyFlag);
145	}	150	}
146	assertTrue("Should have complained about modifying a read-only unit:", didComplain);	151	assertTrue("Should have complained about modifying a read-only unit:", didComplain);
147	assertTrue("ReadOnly buffer got modified:", !this.cu.getBuffer().getContents().equals("invalid"));	152	assertTrue("ReadOnly buffer got modified:", !this.cu.getBuffer().getContents().equals("invalid"));
Lines 152-157 Link Here
152	* provider allows it.	157	* provider allows it.
153	*/	158	*/
154	public void testChangeContentOfReadOnlyCU2() throws CoreException {	159	public void testChangeContentOfReadOnlyCU2() throws CoreException {
		160	if (!Util.isReadOnlySupported()) {
		161	// Do not test if file system does not support read-only attribute
		162	return;
		163	}
155	String newContents =	164	String newContents =
156	"package x.y;\n" +	165	"package x.y;\n" +
157	"public class A {\n" +	166	"public class A {\n" +
Lines 160-170 Link Here
160	"}";	169	"}";
161	IResource resource = this.cu.getUnderlyingResource();	170	IResource resource = this.cu.getUnderlyingResource();
162	IProject project = resource.getProject();	171	IProject project = resource.getProject();
163	boolean readOnlyFlag = isReadOnly(resource);	172	boolean readOnlyFlag = Util.isReadOnly(resource);
164	try {	173	try {
165	RepositoryProvider.map(project, TestPessimisticProvider.NATURE_ID);	174	RepositoryProvider.map(project, TestPessimisticProvider.NATURE_ID);
166	TestPessimisticProvider.markWritableOnSave = true;	175	TestPessimisticProvider.markWritableOnSave = true;
167	setReadOnly(resource, true);	176	Util.setReadOnly(resource, true);
168		177
169	this.copy.getBuffer().setContents(newContents);	178	this.copy.getBuffer().setContents(newContents);
170	this.copy.commitWorkingCopy(true, null);	179	this.copy.commitWorkingCopy(true, null);
Lines 175-181 Link Here
175	} finally {	184	} finally {
176	TestPessimisticProvider.markWritableOnSave = false;	185	TestPessimisticProvider.markWritableOnSave = false;
177	RepositoryProvider.unmap(project);	186	RepositoryProvider.unmap(project);
178	setReadOnly(resource, readOnlyFlag);	187	Util.setReadOnly(resource, readOnlyFlag);
179	}	188	}
180	}	189	}
181		190

Lines 17-22 Link Here

(-)src/org/eclipse/jdt/core/tests/model/CopyMoveResourcesTests.java (-29 / +38 lines)
17	import org.eclipse.core.runtime.IProgressMonitor;	17	import org.eclipse.core.runtime.IProgressMonitor;
18	import org.eclipse.core.runtime.QualifiedName;	18	import org.eclipse.core.runtime.QualifiedName;
19	import org.eclipse.jdt.core.*;	19	import org.eclipse.jdt.core.*;
		20	import org.eclipse.jdt.internal.core.util.Util;
20		21
21	public class CopyMoveResourcesTests extends CopyMoveTests {	22	public class CopyMoveResourcesTests extends CopyMoveTests {
22	/**	23	/**
Lines 329-335 Link Here
329	"public class X {\n" +	330	"public class X {\n" +
330	"}"	331	"}"
331	);	332	);
332	setReadOnly(file, true);	333	Util.setReadOnly(file, true);
333	ICompilationUnit cuSource = getCompilationUnit("/P/src/p1/X.java");	334	ICompilationUnit cuSource = getCompilationUnit("/P/src/p1/X.java");
334		335
335	this.createFolder("/P/src/p2");	336	this.createFolder("/P/src/p2");
Lines 341-350 Link Here
341	assertTrue("Destination cu should be read-only", file2.isReadOnly());	342	assertTrue("Destination cu should be read-only", file2.isReadOnly());
342	} finally {	343	} finally {
343	if (file != null) {	344	if (file != null) {
344	setReadOnly(file, false);	345	Util.setReadOnly(file, false);
345	}	346	}
346	if (file2 != null) {	347	if (file2 != null) {
347	setReadOnly(file2, false);	348	Util.setReadOnly(file2, false);
348	}	349	}
349	deleteFolder("/P/src/p1");	350	deleteFolder("/P/src/p1");
350	deleteFolder("/P/src/p2");	351	deleteFolder("/P/src/p2");
Lines 486-491 Link Here
486	* Ensures that a package fragment can be copied to a different package fragment root.	487	* Ensures that a package fragment can be copied to a different package fragment root.
487	*/	488	*/
488	public void testCopyReadOnlyPackageFragment() throws CoreException {	489	public void testCopyReadOnlyPackageFragment() throws CoreException {
		490	if (!Util.isReadOnlySupported()) {
		491	// Do not test if file system does not support read-only attribute
		492	return;
		493	}
489	IPackageFragment pkgSource = null;	494	IPackageFragment pkgSource = null;
490	IPackageFragment pkg2 = null;	495	IPackageFragment pkg2 = null;
491	try {	496	try {
Lines 496-537 Link Here
496	"public class X {\n" +	501	"public class X {\n" +
497	"}"	502	"}"
498	);	503	);
499	setReadOnly(getFile("/P/src/p1/p2/p3/X.java"), true);	504	Util.setReadOnly(getFile("/P/src/p1/p2/p3/X.java"), true);
500	pkgSource = getPackage("/P/src/p1");	505	pkgSource = getPackage("/P/src/p1");
501	setReadOnly(pkgSource.getResource(), true);	506	Util.setReadOnly(pkgSource.getResource(), true);
502	pkg2 = getPackage("/P/src/p1/p2/p3");	507	pkg2 = getPackage("/P/src/p1/p2/p3");
503	setReadOnly(pkg2.getResource(), true);	508	Util.setReadOnly(pkg2.getResource(), true);
504		509
505	IPackageFragmentRoot rootDest= getPackageFragmentRoot("P", "src2");	510	IPackageFragmentRoot rootDest= getPackageFragmentRoot("P", "src2");
506		511
507	copyPositive(pkg2, rootDest, null, null, false);	512	copyPositive(pkg2, rootDest, null, null, false);
508		513
509	assertTrue("Not readOnly", isReadOnly(getPackage("/P/src2/p1").getResource()));	514	assertTrue("Not readOnly", Util.isReadOnly(getPackage("/P/src2/p1").getResource()));
510	assertTrue("Is readOnly", !isReadOnly(getPackage("/P/src2/p1/p2").getResource()));	515	assertTrue("Is readOnly", !Util.isReadOnly(getPackage("/P/src2/p1/p2").getResource()));
511	assertTrue("Not readOnly", isReadOnly(getPackage("/P/src2/p1/p2/p3").getResource()));	516	assertTrue("Not readOnly", Util.isReadOnly(getPackage("/P/src2/p1/p2/p3").getResource()));
512	assertTrue("Is readOnly", isReadOnly(getFile("/P/src2/p1/p2/p3/X.java")));	517	assertTrue("Is readOnly", Util.isReadOnly(getFile("/P/src2/p1/p2/p3/X.java")));
513	} finally {	518	} finally {
514	IFile xSrcFile = getFile("/P/src/p1/p2/p3/X.java");	519	IFile xSrcFile = getFile("/P/src/p1/p2/p3/X.java");
515	if (xSrcFile != null) {	520	if (xSrcFile != null) {
516	setReadOnly(xSrcFile, false);	521	Util.setReadOnly(xSrcFile, false);
517	}	522	}
518	if (pkg2 != null) {	523	if (pkg2 != null) {
519	setReadOnly(pkg2.getResource(), false);	524	Util.setReadOnly(pkg2.getResource(), false);
520	}	525	}
521	if (pkgSource != null) {	526	if (pkgSource != null) {
522	setReadOnly(pkgSource.getResource(), false);	527	Util.setReadOnly(pkgSource.getResource(), false);
523	}	528	}
524	IPackageFragment p1Fragment = getPackage("/P/src2/p1");	529	IPackageFragment p1Fragment = getPackage("/P/src2/p1");
525	if (p1Fragment != null) {	530	if (p1Fragment != null) {
526	setReadOnly(p1Fragment.getResource(), false);	531	Util.setReadOnly(p1Fragment.getResource(), false);
527	}	532	}
528	IPackageFragment p3Fragment = getPackage("/P/src2/p1/p2/p3");	533	IPackageFragment p3Fragment = getPackage("/P/src2/p1/p2/p3");
529	if (p3Fragment != null) {	534	if (p3Fragment != null) {
530	setReadOnly(p3Fragment.getResource(), false);	535	Util.setReadOnly(p3Fragment.getResource(), false);
531	}	536	}
532	IFile xFile = getFile("/P/src2/p1/p2/p3/X.java");	537	IFile xFile = getFile("/P/src2/p1/p2/p3/X.java");
533	if (xFile != null) {	538	if (xFile != null) {
534	setReadOnly(xFile, false);	539	Util.setReadOnly(xFile, false);
535	}	540	}
536	deleteFolder("/P/src/p1");	541	deleteFolder("/P/src/p1");
537	}	542	}
Lines 924-929 Link Here
924	* Ensures that a package fragment can be copied to a different package fragment root.	929	* Ensures that a package fragment can be copied to a different package fragment root.
925	*/	930	*/
926	public void testMoveReadOnlyPackageFragment() throws CoreException {	931	public void testMoveReadOnlyPackageFragment() throws CoreException {
		932	if (!Util.isReadOnlySupported()) {
		933	// Do not test if file system does not support read-only attribute
		934	return;
		935	}
927	IPackageFragment pkgSource = null;	936	IPackageFragment pkgSource = null;
928	IPackageFragment pkg2 = null;	937	IPackageFragment pkg2 = null;
929	try {	938	try {
Lines 934-975 Link Here
934	"public class X {\n" +	943	"public class X {\n" +
935	"}"	944	"}"
936	);	945	);
937	setReadOnly(getFile("/P/src/p1/p2/p3/X.java"), true);	946	Util.setReadOnly(getFile("/P/src/p1/p2/p3/X.java"), true);
938	pkgSource = getPackage("/P/src/p1");	947	pkgSource = getPackage("/P/src/p1");
939	setReadOnly(pkgSource.getResource(), true);	948	Util.setReadOnly(pkgSource.getResource(), true);
940	pkg2 = getPackage("/P/src/p1/p2/p3");	949	pkg2 = getPackage("/P/src/p1/p2/p3");
941	setReadOnly(pkg2.getResource(), true);	950	Util.setReadOnly(pkg2.getResource(), true);
942		951
943	IPackageFragmentRoot rootDest= getPackageFragmentRoot("P", "src2");	952	IPackageFragmentRoot rootDest= getPackageFragmentRoot("P", "src2");
944		953
945	movePositive(pkg2, rootDest, null, null, false);	954	movePositive(pkg2, rootDest, null, null, false);
946		955
947	assertTrue("Not readOnly", isReadOnly(getPackage("/P/src2/p1").getResource()));	956	assertTrue("Not readOnly", Util.isReadOnly(getPackage("/P/src2/p1").getResource()));
948	assertTrue("Is readOnly", !isReadOnly(getPackage("/P/src2/p1/p2").getResource()));	957	assertTrue("Is readOnly", !Util.isReadOnly(getPackage("/P/src2/p1/p2").getResource()));
949	assertTrue("Not readOnly", isReadOnly(getPackage("/P/src2/p1/p2/p3").getResource()));	958	assertTrue("Not readOnly", Util.isReadOnly(getPackage("/P/src2/p1/p2/p3").getResource()));
950	assertTrue("Is readOnly", isReadOnly(getFile("/P/src2/p1/p2/p3/X.java")));	959	assertTrue("Is readOnly", Util.isReadOnly(getFile("/P/src2/p1/p2/p3/X.java")));
951	} finally {	960	} finally {
952	IFile xSrcFile = getFile("/P/src/p1/p2/p3/X.java");	961	IFile xSrcFile = getFile("/P/src/p1/p2/p3/X.java");
953	if (xSrcFile != null) {	962	if (xSrcFile != null) {
954	setReadOnly(xSrcFile, false);	963	Util.setReadOnly(xSrcFile, false);
955	}	964	}
956	if (pkg2 != null) {	965	if (pkg2 != null) {
957	setReadOnly(pkg2.getResource(), false);	966	Util.setReadOnly(pkg2.getResource(), false);
958	}	967	}
959	if (pkgSource != null) {	968	if (pkgSource != null) {
960	setReadOnly(pkgSource.getResource(), false);	969	Util.setReadOnly(pkgSource.getResource(), false);
961	}	970	}
962	IPackageFragment p1Fragment = getPackage("/P/src2/p1");	971	IPackageFragment p1Fragment = getPackage("/P/src2/p1");
963	if (p1Fragment != null) {	972	if (p1Fragment != null) {
964	setReadOnly(p1Fragment.getResource(), false);	973	Util.setReadOnly(p1Fragment.getResource(), false);
965	}	974	}
966	IPackageFragment p3Fragment = getPackage("/P/src2/p1/p2/p3");	975	IPackageFragment p3Fragment = getPackage("/P/src2/p1/p2/p3");
967	if (p3Fragment != null) {	976	if (p3Fragment != null) {
968	setReadOnly(p3Fragment.getResource(), false);	977	Util.setReadOnly(p3Fragment.getResource(), false);
969	}	978	}
970	IFile xFile = getFile("/P/src2/p1/p2/p3/X.java");	979	IFile xFile = getFile("/P/src2/p1/p2/p3/X.java");
971	if (xFile != null) {	980	if (xFile != null) {
972	setReadOnly(xFile, false);	981	Util.setReadOnly(xFile, false);
973	}	982	}
974	deleteFolder("/P/src/p1");	983	deleteFolder("/P/src/p1");
975	}	984	}

Lines 330-348 Link Here

(-)src/org/eclipse/jdt/core/tests/model/ModifyingResourceTests.java (-15 lines)
330	return JavaCore.newSourceEntry(folderPath, accessibleFiles, nonAccessibleFiles, null);	330	return JavaCore.newSourceEntry(folderPath, accessibleFiles, nonAccessibleFiles, null);
331	}	331	}
332	}	332	}
333	public void setReadOnly(IResource resource, boolean readOnly) throws CoreException {
334	ResourceAttributes resourceAttributes = resource.getResourceAttributes();
335	if (resourceAttributes != null) {
336	resourceAttributes.setReadOnly(readOnly);
337	resource.setResourceAttributes(resourceAttributes);
338	}
339	}
340
341	public boolean isReadOnly(IResource resource) throws CoreException {
342	ResourceAttributes resourceAttributes = resource.getResourceAttributes();
343	if (resourceAttributes != null) {
344	return resourceAttributes.isReadOnly();
345	}
346	return false;
347	}
348	}	333	}