| /******************************************************************************* |
| * Copyright (c) 2004, 2017 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * James Blackburn (Broadcom Corp.) - ongoing development |
| * Sergey Prigogin (Google) - [464072] Refresh on Access ignored during text search |
| *******************************************************************************/ |
| package org.eclipse.core.tests.resources; |
| |
| import java.io.*; |
| import junit.framework.Test; |
| import junit.framework.TestSuite; |
| import org.eclipse.core.internal.preferences.EclipsePreferences; |
| import org.eclipse.core.resources.*; |
| import org.eclipse.core.runtime.*; |
| import org.eclipse.core.runtime.content.*; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.core.runtime.preferences.IEclipsePreferences; |
| import org.eclipse.core.runtime.preferences.InstanceScope; |
| import org.osgi.service.prefs.BackingStoreException; |
| |
| public class CharsetTest extends ResourceTest { |
| |
| public class CharsetVerifier extends ResourceDeltaVerifier { |
| final static int IGNORE_BACKGROUND_THREAD = 0x02; |
| final static int IGNORE_CREATION_THREAD = 0x01; |
| private Thread creationThread = Thread.currentThread(); |
| private int flags; |
| |
| CharsetVerifier(int flags) { |
| this.flags = flags; |
| } |
| |
| @Override |
| void internalVerifyDelta(IResourceDelta delta) { |
| // do NOT ignore any changes to project preferences only to .project |
| IPath path = delta.getFullPath(); |
| if (path.segmentCount() == 2 && path.segment(1).equals(".project")) { |
| return; |
| } |
| super.internalVerifyDelta(delta); |
| } |
| |
| private boolean isSet(int mask) { |
| return (mask & flags) == mask; |
| } |
| |
| @Override |
| public synchronized void resourceChanged(IResourceChangeEvent e) { |
| // to make testing easier, we allow events from the main or other thread to be ignored |
| if (isSet(IGNORE_BACKGROUND_THREAD) && Thread.currentThread() != creationThread) { |
| return; |
| } |
| if (isSet(IGNORE_CREATION_THREAD) && Thread.currentThread() == creationThread) { |
| return; |
| } |
| super.resourceChanged(e); |
| this.notify(); |
| } |
| |
| public synchronized boolean waitForEvent(long limit) { |
| if (hasBeenNotified()) { |
| return true; |
| } |
| try { |
| this.wait(limit); |
| } catch (InterruptedException e) { |
| // ignore |
| } |
| return hasBeenNotified(); |
| } |
| } |
| |
| static final String SAMPLE_SPECIFIC_XML = "<?xml version=\"1.0\"?><org.eclipse.core.tests.resources.anotherXML/>"; |
| private static final String SAMPLE_XML_DEFAULT_ENCODING = "<?xml version=\"1.0\"?><org.eclipse.core.resources.tests.root/>"; |
| static final String SAMPLE_XML_ISO_8859_1_ENCODING = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><org.eclipse.core.resources.tests.root/>"; |
| static final String SAMPLE_XML_US_ASCII_ENCODING = "<?xml version=\"1.0\" encoding=\"US-ASCII\"?><org.eclipse.core.resources.tests.root/>"; |
| |
| static final String SAMPLE_DERIVED_ENCODING_TO_FALSE_REGULAR_PREFS = "#Mon Nov 15 17:54:11 CET 2010\n" + ResourcesPlugin.PREF_SEPARATE_DERIVED_ENCODINGS + "=false\neclipse.preferences.version=1"; |
| static final String SAMPLE_DERIVED_ENCODING_AFTER_FALSE_REGULAR_PREFS[] = new String[] {ResourcesPlugin.PREF_SEPARATE_DERIVED_ENCODINGS + "=false", "encoding//b1/a.txt=UTF-8", "eclipse.preferences.version=1"}; |
| |
| static final String SAMPLE_DERIVED_ENCODING_TO_TRUE_REGULAR_PREFS = "#Mon Nov 15 17:54:11 CET 2010\n" + ResourcesPlugin.PREF_SEPARATE_DERIVED_ENCODINGS + "=true\nencoding//b1/a.txt=UTF-8\neclipse.preferences.version=1"; |
| static final String SAMPLE_DERIVED_ENCODING_AFTER_TRUE_REGULAR_PREFS[] = new String[] {ResourcesPlugin.PREF_SEPARATE_DERIVED_ENCODINGS + "=true", "eclipse.preferences.version=1"}; |
| static final String SAMPLE_DERIVED_ENCODING_AFTER_TRUE_DERIVED_PREFS[] = new String[] {"encoding//b1/a.txt=UTF-8", "eclipse.preferences.version=1"}; |
| |
| private String savedWorkspaceCharset; |
| |
| public static Test suite() { |
| // TestSuite suite = new TestSuite(); |
| // suite.addTest(new CharsetTest("testFileCreation")); |
| // suite.addTest(new CharsetTest("testPrefsFileCreation")); |
| // return suite; |
| // return new CharsetTest("testMovingProject"); |
| |
| return new TestSuite(CharsetTest.class); |
| |
| // // cause the same test to run several times to catch a timing problem |
| // TestSuite suite = new TestSuite(); |
| // for (int i = 0; i < 1000; i++) |
| // suite.addTest(new CharsetTest("testDeltasFile")); |
| // return suite; |
| } |
| |
| public CharsetTest(String name) { |
| super(name); |
| } |
| |
| /** |
| * See bug 67606. |
| * |
| * TODO enable when bug is fixed |
| */ |
| public void _testBug67606() throws CoreException { |
| IWorkspace workspace = getWorkspace(); |
| final IProject project = workspace.getRoot().getProject("MyProject"); |
| try { |
| final IFile file = project.getFile("file.txt"); |
| ensureExistsInWorkspace(file, true); |
| project.setDefaultCharset("FOO", getMonitor()); |
| workspace.run((IWorkspaceRunnable) monitor -> { |
| assertEquals("0.9", "FOO", file.getCharset()); |
| file.setCharset("BAR", getMonitor()); |
| assertEquals("1.0", "BAR", file.getCharset()); |
| file.move(project.getFullPath().append("file2.txt"), IResource.NONE, monitor); |
| IFile file2 = project.getFile("file2.txt"); |
| assertExistsInWorkspace(file2, false); |
| assertEquals("2.0", "BAR", file.getCharset()); |
| }, null); |
| } finally { |
| ensureDoesNotExistInWorkspace(project); |
| } |
| } |
| |
| /** |
| * Asserts that the given resources have the given [default] charset. |
| */ |
| private void assertCharsetIs(String tag, String encoding, IResource[] resources, boolean checkImplicit) throws CoreException { |
| for (IResource resource : resources) { |
| String resourceCharset = resource instanceof IFile ? ((IFile) resource).getCharset(checkImplicit) : ((IContainer) resource).getDefaultCharset(checkImplicit); |
| assertEquals(tag + " " + resource.getFullPath(), encoding, resourceCharset); |
| } |
| } |
| |
| // private void checkPreferencesContent(String tag, IFile prefs, String[] lines) { |
| // BufferedReader br = null; |
| // try { |
| // br = new BufferedReader(new FileReader(prefs.getLocation().toFile())); |
| // List<String> actualList = new ArrayList<String>(); |
| // String line = br.readLine(); |
| // while (line != null) { |
| // if (!line.startsWith("#")) { |
| // actualList.add(line); |
| // } |
| // line = br.readLine(); |
| // } |
| // |
| // assertEquals(tag, lines.length, actualList.size()); |
| // List<String> expectedLines = Arrays.asList(lines); |
| // Collections.sort(expectedLines); |
| // Collections.sort(actualList); |
| // for (int i = 0; i < expectedLines.size(); i++) { |
| // assertTrue(tag, expectedLines.get(i).equals(actualList.get(i))); |
| // } |
| // } catch (FileNotFoundException e) { |
| // fail(tag, e); |
| // } catch (IOException e) { |
| // fail(tag, e); |
| // } finally { |
| // if (br != null) |
| // try { |
| // br.close(); |
| // } catch (IOException e) { |
| // fail(tag, e); |
| // } |
| // } |
| // } |
| |
| private void clearAllEncodings(IResource root) throws CoreException { |
| if (root == null || !root.exists()) { |
| return; |
| } |
| IResourceVisitor visitor = resource -> { |
| if (!resource.exists()) { |
| return false; |
| } |
| switch (resource.getType()) { |
| case IResource.FILE : |
| ((IFile) resource).setCharset(null, getMonitor()); |
| break; |
| case IResource.ROOT : |
| // do nothing |
| break; |
| default : |
| ((IContainer) resource).setDefaultCharset(null, getMonitor()); |
| } |
| return true; |
| }; |
| root.accept(visitor); |
| } |
| |
| private IFile getResourcesPreferenceFile(IProject project, boolean forDerivedResources) { |
| if (forDerivedResources) { |
| return project.getFolder(EclipsePreferences.DEFAULT_PREFERENCES_DIRNAME).getFile(ResourcesPlugin.PI_RESOURCES + ".derived." + EclipsePreferences.PREFS_FILE_EXTENSION); |
| } |
| return project.getFolder(EclipsePreferences.DEFAULT_PREFERENCES_DIRNAME).getFile(ResourcesPlugin.PI_RESOURCES + "." + EclipsePreferences.PREFS_FILE_EXTENSION); |
| } |
| |
| private Reader getTextContents(String text) { |
| return new StringReader(text); |
| } |
| |
| private boolean isDerivedEncodingStoredSeparately(IProject project) { |
| org.osgi.service.prefs.Preferences node = Platform.getPreferencesService().getRootNode().node(ProjectScope.SCOPE); |
| String projectName = project.getName(); |
| try { |
| if (!node.nodeExists(projectName)) { |
| return false; |
| } |
| node = node.node(projectName); |
| if (!node.nodeExists(ResourcesPlugin.PI_RESOURCES)) { |
| return false; |
| } |
| node = node.node(ResourcesPlugin.PI_RESOURCES); |
| return node.getBoolean(ResourcesPlugin.PREF_SEPARATE_DERIVED_ENCODINGS, false); |
| } catch (BackingStoreException e) { |
| // default value |
| return false; |
| } |
| } |
| |
| private void setDerivedEncodingStoredSeparately(String tag, IProject project, boolean value) { |
| org.osgi.service.prefs.Preferences prefs = new ProjectScope(project).getNode(ResourcesPlugin.PI_RESOURCES); |
| if (!value) { |
| prefs.remove(ResourcesPlugin.PREF_SEPARATE_DERIVED_ENCODINGS); |
| } else { |
| prefs.putBoolean(ResourcesPlugin.PREF_SEPARATE_DERIVED_ENCODINGS, true); |
| } |
| try { |
| prefs.flush(); |
| } catch (BackingStoreException e) { |
| fail(tag, e); |
| } |
| } |
| |
| private static IEclipsePreferences getResourcesPreferences() { |
| return InstanceScope.INSTANCE.getNode(ResourcesPlugin.PI_RESOURCES); |
| } |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| // save the workspace charset so it can be restored after the test |
| savedWorkspaceCharset = ResourcesPlugin.getPlugin().getPluginPreferences().getString(ResourcesPlugin.PREF_ENCODING); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| // restore the workspace charset |
| ResourcesPlugin.getPlugin().getPluginPreferences().setValue(ResourcesPlugin.PREF_ENCODING, savedWorkspaceCharset); |
| // Reset the PREF_LIGHTWEIGHT_AUTO_REFRESH preference to its default value. |
| getResourcesPreferences().remove(ResourcesPlugin.PREF_LIGHTWEIGHT_AUTO_REFRESH); |
| super.tearDown(); |
| } |
| |
| public void testBug59899() { |
| IWorkspace workspace = getWorkspace(); |
| IProject project = workspace.getRoot().getProject(getUniqueString()); |
| try { |
| IFile file = project.getFile("file.txt"); |
| IFolder folder = project.getFolder("folder"); |
| ensureExistsInWorkspace(new IResource[] {file, folder}, true); |
| try { |
| file.setCharset("FOO", getMonitor()); |
| } catch (CoreException e) { |
| fail("1.0", e); |
| } |
| try { |
| folder.setDefaultCharset("BAR", getMonitor()); |
| } catch (CoreException e) { |
| fail("2.0", e); |
| } |
| try { |
| project.setDefaultCharset("PROJECT_CHARSET", getMonitor()); |
| } catch (CoreException e) { |
| fail("3.0", e); |
| } |
| try { |
| getWorkspace().getRoot().setDefaultCharset("ROOT_CHARSET", getMonitor()); |
| } catch (CoreException e) { |
| fail("4.0", e); |
| } |
| } finally { |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| } |
| |
| public void testBug62732() throws UnsupportedEncodingException, CoreException { |
| IWorkspace workspace = getWorkspace(); |
| IProject project = workspace.getRoot().getProject("MyProject"); |
| IContentTypeManager contentTypeManager = Platform.getContentTypeManager(); |
| IContentType anotherXML = contentTypeManager.getContentType("org.eclipse.core.tests.resources.anotherXML"); |
| assertNotNull("0.5", anotherXML); |
| ensureExistsInWorkspace(project, true); |
| IFile file = project.getFile("file.xml"); |
| ensureExistsInWorkspace(file, new ByteArrayInputStream(SAMPLE_SPECIFIC_XML.getBytes("UTF-8"))); |
| IContentDescription description = file.getContentDescription(); |
| assertNotNull("1.0", description); |
| assertEquals("1.1", anotherXML, description.getContentType()); |
| description = file.getContentDescription(); |
| assertNotNull("2.0", description); |
| assertEquals("2.1", anotherXML, description.getContentType()); |
| } |
| |
| public void testBug64503() throws CoreException { |
| IWorkspace workspace = getWorkspace(); |
| IProject project = workspace.getRoot().getProject("MyProject"); |
| IContentTypeManager contentTypeManager = Platform.getContentTypeManager(); |
| IContentType text = contentTypeManager.getContentType("org.eclipse.core.runtime.text"); |
| IFile file = project.getFile("file.txt"); |
| ensureExistsInWorkspace(file, true); |
| IContentDescription description = file.getContentDescription(); |
| assertNotNull("1.0", description); |
| assertEquals("1.1", text, description.getContentType()); |
| ensureDoesNotExistInWorkspace(file); |
| try { |
| description = file.getContentDescription(); |
| fail("1.2 - should have failed"); |
| } catch (CoreException e) { |
| // Ok, the resource does not exist. |
| assertEquals("1.3", IResourceStatus.RESOURCE_NOT_FOUND, e.getStatus().getCode()); |
| } |
| } |
| |
| public void testBug94279() throws CoreException { |
| final IWorkspaceRoot root = getWorkspace().getRoot(); |
| String originalUserCharset = root.getDefaultCharset(false); |
| try { |
| root.setDefaultCharset(null); |
| assertNull("1.0", root.getDefaultCharset(false)); |
| } finally { |
| if (originalUserCharset != null) { |
| root.setDefaultCharset(originalUserCharset); |
| } |
| } |
| } |
| |
| public void testBug333056() throws CoreException { |
| IProject project = null; |
| try { |
| IWorkspace workspace = getWorkspace(); |
| project = workspace.getRoot().getProject("MyProject"); |
| ensureExistsInWorkspace(project, true); |
| project.setDefaultCharset("BAR", getMonitor()); |
| |
| IFolder folder = project.getFolder(getUniqueString()); |
| IFile file = folder.getFile(getUniqueString()); |
| assertEquals("1.0", "BAR", file.getCharset(true)); |
| |
| ensureExistsInWorkspace(folder, true); |
| assertEquals("2.0", "BAR", file.getCharset(true)); |
| |
| folder.setDerived(true, getMonitor()); |
| assertEquals("3.0", "BAR", file.getCharset(true)); |
| |
| setDerivedEncodingStoredSeparately("4.0", project, true); |
| assertEquals("5.0", "BAR", file.getCharset(true)); |
| } finally { |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("6.0", e); |
| } |
| } |
| } |
| |
| /** |
| * Test for getting charset on an IFile: |
| * #getContentDescription() checks file sync state(), always returning the |
| * correct content description, whereas getCharset() uses the cached charset if available. |
| * @throws Exception |
| */ |
| public void testBug186984() throws Exception { |
| getResourcesPreferences().putBoolean(ResourcesPlugin.PREF_LIGHTWEIGHT_AUTO_REFRESH, false); |
| IWorkspace workspace = getWorkspace(); |
| IProject project = workspace.getRoot().getProject(getUniqueString()); |
| IFile file = project.getFile("file.xml"); |
| |
| // Test changing content types externally as per bug 186984 Comment 8 |
| String ascii = "<?xml version=\"1.0\" encoding=\"ascii\"?>"; |
| String utf = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"; |
| |
| // test that we can get the charset, when the file doesn't exist in a file system |
| try { |
| file.getCharset(true); |
| } catch (CoreException ex) { |
| fail("1.0"); |
| } |
| |
| // test that we can get the charset, when the file is out-of-sync |
| ensureExistsInWorkspace(file, true); |
| try { |
| if (!file.getLocation().toFile().delete()) { |
| fail("2.0"); |
| } |
| file.getCharset(true); |
| } catch (CoreException ex) { |
| fail("2.1"); |
| } |
| |
| ensureExistsInFileSystem(file); |
| ensureOutOfSync(file); |
| //getCharset uses a cached value, so it will still pass |
| try { |
| file.getCharset(true); |
| } catch (CoreException ex) { |
| fail("3.0"); |
| } |
| |
| // set the content type within the XML file, ensure that #getContentDescription (which respects sync state) |
| // returns the correct value. |
| |
| // 1) first set the content type to ascii |
| file.setContents(new ByteArrayInputStream(ascii.getBytes("ascii")), IResource.FORCE, getMonitor()); |
| assertTrue("4.0", file.getCharset().equals("ascii")); |
| assertTrue("4.1", file.getContentDescription().getCharset().equals("ascii")); |
| |
| // 2) Make out of sync - Methods should still work, giving the previous value |
| touchInFilesystem(file); |
| assertTrue("4.2", file.getCharset().equals("ascii")); |
| try { |
| file.getContentDescription().getCharset().equals("ascii"); |
| assertTrue("4.3", false); |
| } catch (CoreException e) { |
| // Ok, the file is out of sync. |
| assertEquals("4.4", IResourceStatus.OUT_OF_SYNC_LOCAL, e.getStatus().getCode()); |
| } |
| |
| // As we now know that #getContentDescription correctly checks sync state, just enable LIGHTWEIGHT refresh |
| // for the rest of the test. |
| getResourcesPreferences().putBoolean(ResourcesPlugin.PREF_LIGHTWEIGHT_AUTO_REFRESH, true); |
| assertTrue("4.5", file.getContentDescription().getCharset().equals("ascii")); |
| |
| // getContentDescription will have noticed out-of-sync |
| Job.getJobManager().join(ResourcesPlugin.FAMILY_AUTO_REFRESH, getMonitor()); |
| // Prime the cache... |
| assertTrue("4.6", file.getCharset().equals("ascii")); |
| |
| // 3) Change the content type of the file under eclipse's feet |
| FileWriter writer = new FileWriter(file.getLocation().toFile()); |
| writer.write(utf); |
| writer.close(); |
| touchInFilesystem(file); |
| // #getCharset uses the cached value (bug 209167) - doesn't check sync state |
| assertTrue("5.4", file.getCharset().equals("ascii")); |
| // #getContentDescription checks sync and discovers the real content type |
| assertTrue("5.5", file.getContentDescription().getCharset().equals("UTF-8")); |
| // getContentDescription will have noticed out-of-sync |
| Job.getJobManager().join(ResourcesPlugin.FAMILY_AUTO_REFRESH, getMonitor()); |
| // #getCharset will now have noticed that the file has changed. |
| assertTrue("5.6", file.getCharset().equals("UTF-8")); |
| |
| // 4) Change the content type of the file under eclipse's feet once more (to non-default). |
| writer = new FileWriter(file.getLocation().toFile()); |
| writer.write(ascii); |
| writer.close(); |
| touchInFilesystem(file); |
| // #getCharset uses the cached value (bug 209167) - doesn't check sync state |
| assertTrue("6.7", file.getCharset().equals("UTF-8")); |
| // #getContentDescription checks sync and discovers the real content type |
| assertTrue("6.8", file.getContentDescription().getCharset().equals("ascii")); |
| // getContentDescription will have noticed out-of-sync |
| Job.getJobManager().join(ResourcesPlugin.FAMILY_AUTO_REFRESH, getMonitor()); |
| assertTrue("6.9", file.getCharset().equals("ascii")); |
| } |
| |
| public void testBug207510() { |
| IWorkspace workspace = getWorkspace(); |
| CharsetVerifier verifier = new CharsetVerifier(CharsetVerifier.IGNORE_BACKGROUND_THREAD); |
| CharsetVerifier backgroundVerifier = new CharsetVerifier(CharsetVerifier.IGNORE_CREATION_THREAD); |
| IProject project1 = workspace.getRoot().getProject("project1"); |
| try { |
| workspace.addResourceChangeListener(verifier, IResourceChangeEvent.POST_CHANGE); |
| workspace.addResourceChangeListener(backgroundVerifier, IResourceChangeEvent.POST_CHANGE); |
| |
| IFolder a1 = project1.getFolder("a1"); |
| IFolder b1 = project1.getFolder("b1"); |
| IFile a = a1.getFile("a.txt"); |
| ensureExistsInWorkspace(new IResource[] {project1, a1, b1, a}, true); |
| try { |
| verifier.reset(); |
| verifier.addExpectedChange(b1, IResourceDelta.CHANGED, IResourceDelta.DERIVED_CHANGED); |
| b1.setDerived(true, getMonitor()); |
| verifier.waitForEvent(10000); |
| } catch (CoreException e) { |
| fail("0.1", e); |
| } |
| IFile regularPrefs = getResourcesPreferenceFile(project1, false); |
| IFile derivedPrefs = getResourcesPreferenceFile(project1, true); |
| assertDoesNotExistInWorkspace("0.2", regularPrefs); |
| assertDoesNotExistInWorkspace("0.3", derivedPrefs); |
| |
| //1 - setting preference on project |
| verifier.reset(); |
| verifier.addExpectedChange(regularPrefs.getParent(), IResourceDelta.ADDED, 0); |
| verifier.addExpectedChange(regularPrefs, IResourceDelta.ADDED, 0); |
| setDerivedEncodingStoredSeparately("1.0", project1, true); |
| assertTrue("1.1", verifier.waitForEvent(10000)); |
| assertTrue("1.2 " + verifier.getMessage(), verifier.isDeltaValid()); |
| assertExistsInWorkspace("1.3", regularPrefs); |
| assertDoesNotExistInWorkspace("1.4", derivedPrefs); |
| assertTrue("1.5", isDerivedEncodingStoredSeparately(project1)); |
| |
| //2 - changing charset for file |
| verifier.reset(); |
| verifier.addExpectedChange(a, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| verifier.addExpectedChange(regularPrefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| try { |
| a.setCharset("UTF-8", getMonitor()); |
| } catch (CoreException e) { |
| fail("2.0", e); |
| } |
| assertTrue("2.1", verifier.waitForEvent(10000)); |
| assertTrue("2.2 " + verifier.getMessage(), verifier.isDeltaValid()); |
| assertExistsInWorkspace("2.3", regularPrefs); |
| assertDoesNotExistInWorkspace("2.4", derivedPrefs); |
| |
| //3 - setting derived == 'true' for file |
| // TODO update the test when bug 345271 is fixed |
| try { |
| a.setDerived(true, getMonitor()); |
| } catch (CoreException e) { |
| fail("3.0", e); |
| } |
| //wait for all resource deltas |
| try { |
| Thread.sleep(5000); |
| } catch (InterruptedException e) { |
| fail("3.0.1", e); |
| } |
| assertExistsInWorkspace("3.1", regularPrefs); |
| assertExistsInWorkspace("3.2", derivedPrefs); |
| assertTrue("3.3", derivedPrefs.isDerived()); |
| |
| //4 - setting derived == 'false' for file |
| // TODO update the test when bug 345271 is fixed |
| try { |
| a.setDerived(false, getMonitor()); |
| } catch (CoreException e) { |
| fail("4.0", e); |
| } |
| //wait for all resource deltas |
| try { |
| Thread.sleep(5000); |
| } catch (InterruptedException e) { |
| fail("4.0.1", e); |
| } |
| assertExistsInWorkspace("4.1", regularPrefs); |
| assertDoesNotExistInWorkspace("4.2", derivedPrefs); |
| |
| //5 - moving file to derived folder |
| IFile source = project1.getFolder("a1").getFile("a.txt"); |
| IFile destination = project1.getFolder("b1").getFile("a.txt"); |
| backgroundVerifier.reset(); |
| backgroundVerifier.addExpectedChange(regularPrefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| backgroundVerifier.addExpectedChange(derivedPrefs, IResourceDelta.ADDED, 0); |
| try { |
| a.move(destination.getFullPath(), true, getMonitor()); |
| a = destination; |
| } catch (CoreException e) { |
| fail("5.0", e); |
| } |
| assertTrue("5.1", backgroundVerifier.waitForEvent(10000)); |
| assertTrue("5.2 " + backgroundVerifier.getMessage(), backgroundVerifier.isDeltaValid()); |
| assertExistsInWorkspace("5.3", regularPrefs); |
| assertExistsInWorkspace("5.4", derivedPrefs); |
| assertDoesNotExistInWorkspace("5.5", source); |
| assertExistsInWorkspace("5.6", destination); |
| assertTrue("5.7", derivedPrefs.isDerived()); |
| try { |
| assertCharsetIs("5.8", "UTF-8", new IResource[] {a}, true); |
| } catch (CoreException e) { |
| fail("5.8.1", e); |
| } |
| |
| //6 - removing preference on project |
| verifier.reset(); |
| backgroundVerifier.reset(); |
| verifier.addExpectedChange(regularPrefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| backgroundVerifier.addExpectedChange(derivedPrefs, IResourceDelta.REMOVED, 0); |
| setDerivedEncodingStoredSeparately("6.0", project1, false); |
| assertTrue("6.1.1", verifier.waitForEvent(10000)); |
| assertTrue("6.1.2", backgroundVerifier.waitForEvent(10000)); |
| assertTrue("6.2.1 " + verifier.getMessage(), verifier.isDeltaValid()); |
| assertTrue("6.2.2 " + backgroundVerifier.getMessage(), backgroundVerifier.isDeltaValid()); |
| assertExistsInWorkspace("6.3", regularPrefs); |
| assertDoesNotExistInWorkspace("6.4", derivedPrefs); |
| |
| //7 - setting preference on project with derived files |
| verifier.reset(); |
| backgroundVerifier.reset(); |
| verifier.addExpectedChange(regularPrefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| backgroundVerifier.addExpectedChange(derivedPrefs, IResourceDelta.ADDED, 0); |
| setDerivedEncodingStoredSeparately("7.0", project1, true); |
| assertTrue("7.1.1", verifier.waitForEvent(10000)); |
| assertTrue("7.1.2", backgroundVerifier.waitForEvent(10000)); |
| assertTrue("7.2.1 " + verifier.getMessage(), verifier.isDeltaValid()); |
| assertTrue("7.2.2 " + backgroundVerifier.getMessage(), backgroundVerifier.isDeltaValid()); |
| assertExistsInWorkspace("7.3", regularPrefs); |
| assertExistsInWorkspace("7.4", derivedPrefs); |
| assertTrue("7.5", isDerivedEncodingStoredSeparately(project1)); |
| assertTrue("7.6", derivedPrefs.isDerived()); |
| |
| // //8 - manually changing preference 'true'->'false' |
| // verifier.reset(); |
| // backgroundVerifier.reset(); |
| // verifier.addExpectedChange(regularPrefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| // backgroundVerifier.addExpectedChange(regularPrefs, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| // backgroundVerifier.addExpectedChange(new IResource[] {project1, a1, b1, a, regularPrefs.getParent(), regularPrefs}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| // backgroundVerifier.addExpectedChange(derivedPrefs, IResourceDelta.REMOVED, 0); |
| // assertTrue("7.99", isDerivedEncodingStoredSeparately(project1)); |
| // try { |
| // regularPrefs.setContents(new ByteArrayInputStream(SAMPLE_DERIVED_ENCODING_TO_FALSE_REGULAR_PREFS.getBytes()), 0, getMonitor()); |
| // } catch (CoreException e) { |
| // fail("8.0", e); |
| // } |
| // assertTrue("8.1.1", verifier.waitForEvent(10000)); |
| // assertTrue("8.1.2", backgroundVerifier.waitForEvent(10000)); |
| // assertTrue("8.2.1 " + verifier.getMessage(), verifier.isDeltaValid()); |
| // assertTrue("8.2.2 " + backgroundVerifier.getMessage(), backgroundVerifier.isDeltaValid()); |
| // assertExistsInWorkspace("8.3", regularPrefs); |
| // //checkPreferencesContent("8.3.1", regularPrefs, SAMPLE_DERIVED_ENCODING_AFTER_FALSE_REGULAR_PREFS); |
| // assertDoesNotExistInWorkspace("8.4", derivedPrefs); |
| // assertTrue("8.5", !isDerivedEncodingStoredSeparately(project1)); |
| // try { |
| // assertCharsetIs("8.6", "UTF-8", new IResource[] {a}, true); |
| // } catch (CoreException e) { |
| // fail("8.6.1", e); |
| // } |
| // |
| // //9 - manually changing preference 'false'->'true' |
| // verifier.reset(); |
| // backgroundVerifier.reset(); |
| // verifier.addExpectedChange(regularPrefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| // //backgroundVerifier.addExpectedChange(new IResource[] {project1, a1, b1, a, regularPrefs.getParent(), regularPrefs}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| // backgroundVerifier.addExpectedChange(derivedPrefs, IResourceDelta.ADDED, 0); |
| // assertDoesNotExistInWorkspace("8.98", derivedPrefs); |
| // assertTrue("8.99", !isDerivedEncodingStoredSeparately(project1)); |
| // try { |
| // regularPrefs.setContents(new ByteArrayInputStream(SAMPLE_DERIVED_ENCODING_TO_TRUE_REGULAR_PREFS.getBytes()), 0, getMonitor()); |
| // } catch (CoreException e) { |
| // fail("9.0", e); |
| // } |
| // assertTrue("9.1.1", verifier.waitForEvent(10000)); |
| // assertTrue("9.1.2", backgroundVerifier.waitForEvent(10000)); |
| // assertTrue("9.2.1 " + verifier.getMessage(), verifier.isDeltaValid()); |
| // assertTrue("9.2.2 " + backgroundVerifier.getMessage(), backgroundVerifier.isDeltaValid()); |
| // //updating prefs is run in separate job so wait some time for completion |
| // backgroundVerifier.waitForEvent(10000); |
| // assertExistsInWorkspace("9.3", regularPrefs); |
| // //checkPreferencesContent("9.3.1", regularPrefs, SAMPLE_DERIVED_ENCODING_AFTER_TRUE_REGULAR_PREFS); |
| // assertExistsInWorkspace("9.4", derivedPrefs); |
| // checkPreferencesContent("9.4.1", derivedPrefs, SAMPLE_DERIVED_ENCODING_AFTER_TRUE_DERIVED_PREFS); |
| // assertTrue("9.5", isDerivedEncodingStoredSeparately(project1)); |
| // try { |
| // assertCharsetIs("9.6", "UTF-8", new IResource[] {a}, true); |
| // } catch (CoreException e) { |
| // fail("9.6.1", e); |
| // } |
| // assertTrue("9.7", derivedPrefs.isDerived()); |
| // |
| // //10 - manually changing preference 'true'->'false' outside Eclipse |
| // verifier.reset(); |
| // backgroundVerifier.reset(); |
| // verifier.addExpectedChange(regularPrefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| // backgroundVerifier.addExpectedChange(regularPrefs, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| // backgroundVerifier.addExpectedChange(new IResource[] {project1, a1, b1, a, regularPrefs.getParent(), regularPrefs}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| // backgroundVerifier.addExpectedChange(derivedPrefs, IResourceDelta.REMOVED, 0); |
| // assertTrue("9.99", isDerivedEncodingStoredSeparately(project1)); |
| // try { |
| // File file = regularPrefs.getLocation().toFile(); |
| // BufferedWriter bw = new BufferedWriter(new FileWriter(file)); |
| // bw.write(SAMPLE_DERIVED_ENCODING_TO_FALSE_REGULAR_PREFS); |
| // bw.close(); |
| // regularPrefs.refreshLocal(IResource.DEPTH_ZERO, getMonitor()); |
| // } catch (IOException e) { |
| // fail("10.0.1", e); |
| // } catch (CoreException e) { |
| // fail("10.0.2", e); |
| // } |
| // assertTrue("10.1.1", verifier.waitForEvent(10000)); |
| // assertTrue("10.1.2", backgroundVerifier.waitForEvent(10000)); |
| // assertTrue("10.2.1 " + verifier.getMessage(), verifier.isDeltaValid()); |
| // assertTrue("10.2.2 " + backgroundVerifier.getMessage(), backgroundVerifier.isDeltaValid()); |
| // assertExistsInWorkspace("10.3", regularPrefs); |
| // //checkPreferencesContent("10.3.1", regularPrefs, SAMPLE_DERIVED_ENCODING_AFTER_FALSE_REGULAR_PREFS); |
| // assertDoesNotExistInWorkspace("10.4", derivedPrefs); |
| // assertTrue("10.5", !isDerivedEncodingStoredSeparately(project1)); |
| // try { |
| // assertCharsetIs("10.6", "UTF-8", new IResource[] {a}, true); |
| // } catch (CoreException e) { |
| // fail("10.6.1", e); |
| // } |
| // |
| // //11 - manually changing preference 'false'->'true' outside Eclipse |
| // verifier.reset(); |
| // backgroundVerifier.reset(); |
| // verifier.addExpectedChange(regularPrefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| // //backgroundVerifier.addExpectedChange(new IResource[] {project1, a1, b1, a, regularPrefs.getParent(), regularPrefs}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| // backgroundVerifier.addExpectedChange(derivedPrefs, IResourceDelta.ADDED, 0); |
| // assertDoesNotExistInWorkspace("10.98", derivedPrefs); |
| // assertTrue("10.99", !isDerivedEncodingStoredSeparately(project1)); |
| // try { |
| // File file = regularPrefs.getLocation().toFile(); |
| // BufferedWriter bw = new BufferedWriter(new FileWriter(file)); |
| // bw.write(SAMPLE_DERIVED_ENCODING_TO_TRUE_REGULAR_PREFS); |
| // bw.close(); |
| // regularPrefs.refreshLocal(IResource.DEPTH_ZERO, getMonitor()); |
| // } catch (IOException e) { |
| // fail("11.0.1", e); |
| // } catch (CoreException e) { |
| // fail("11.0.2", e); |
| // } |
| // assertTrue("11.1.1", verifier.waitForEvent(10000)); |
| // assertTrue("11.1.2", backgroundVerifier.waitForEvent(10000)); |
| // assertTrue("11.2.1 " + verifier.getMessage(), verifier.isDeltaValid()); |
| // assertTrue("11.2.2 " + backgroundVerifier.getMessage(), backgroundVerifier.isDeltaValid()); |
| // //updating prefs is run in separate job so wait some time for completion |
| // backgroundVerifier.waitForEvent(10000); |
| // assertExistsInWorkspace("11.3", regularPrefs); |
| // //checkPreferencesContent("11.3.1", regularPrefs, SAMPLE_DERIVED_ENCODING_AFTER_TRUE_REGULAR_PREFS); |
| // assertExistsInWorkspace("11.4", derivedPrefs); |
| // checkPreferencesContent("11.4.1", derivedPrefs, SAMPLE_DERIVED_ENCODING_AFTER_TRUE_DERIVED_PREFS); |
| // assertTrue("11.5", isDerivedEncodingStoredSeparately(project1)); |
| // try { |
| // assertCharsetIs("11.6", "UTF-8", new IResource[] {a}, true); |
| // } catch (CoreException e) { |
| // fail("11.6.1", e); |
| // } |
| // assertTrue("11.7", derivedPrefs.isDerived()); |
| } finally { |
| workspace.removeResourceChangeListener(verifier); |
| workspace.removeResourceChangeListener(backgroundVerifier); |
| try { |
| clearAllEncodings(project1); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| } |
| |
| /** |
| * In this bug, a file starts with a particular content id and content type. It is then |
| * deleted and recreated, with the same content id but a different content type. |
| * This tricks the content type cache into returning an invalid result. |
| */ |
| public void testBug261994() throws UnsupportedEncodingException, CoreException { |
| //recreate a file with different contents but the same content id |
| IWorkspace workspace = getWorkspace(); |
| IProject project1 = workspace.getRoot().getProject("Project1"); |
| IFile file = project1.getFile("file1.xml"); |
| ensureExistsInWorkspace(file, new ByteArrayInputStream(SAMPLE_XML_ISO_8859_1_ENCODING.getBytes("ISO-8859-1"))); |
| ContentDescriptionManagerTest.waitForCacheFlush(); |
| assertEquals("1.0", "ISO-8859-1", file.getCharset()); |
| |
| //delete and recreate the file with different contents |
| ensureDoesNotExistInWorkspace(file); |
| ensureExistsInWorkspace(file, new ByteArrayInputStream(SAMPLE_XML_DEFAULT_ENCODING.getBytes("UTF-8"))); |
| assertEquals("2.0", "UTF-8", file.getCharset()); |
| } |
| |
| public void testChangesDifferentProject() throws CoreException { |
| IWorkspace workspace = getWorkspace(); |
| IProject project1 = workspace.getRoot().getProject("Project1"); |
| IProject project2 = workspace.getRoot().getProject("Project2"); |
| try { |
| IFolder folder = project1.getFolder("folder1"); |
| IFile file1 = project1.getFile("file1.txt"); |
| IFile file2 = folder.getFile("file2.txt"); |
| ensureExistsInWorkspace(new IResource[] {file1, file2, project2}, true); |
| project1.setDefaultCharset("FOO", getMonitor()); |
| project2.setDefaultCharset("ZOO", getMonitor()); |
| folder.setDefaultCharset("BAR", getMonitor()); |
| // move a folder to another project and ensure its encoding is |
| // preserved |
| folder.move(project2.getFullPath().append("folder"), false, false, null); |
| folder = project2.getFolder("folder"); |
| assertEquals("1.0", "BAR", folder.getDefaultCharset()); |
| assertEquals("1.1", "BAR", folder.getFile("file2.txt").getCharset()); |
| // move a file with no charset set and check if it inherits |
| // properly from the new parent |
| assertEquals("2.0", project1.getDefaultCharset(), file1.getCharset()); |
| file1.move(project2.getFullPath().append("file1.txt"), false, false, null); |
| file1 = project2.getFile("file1.txt"); |
| assertEquals("2.1", project2.getDefaultCharset(), file1.getCharset()); |
| } finally { |
| try { |
| clearAllEncodings(project1); |
| clearAllEncodings(project2); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| } |
| |
| public void testChangesSameProject() throws CoreException { |
| IWorkspace workspace = getWorkspace(); |
| IProject project = workspace.getRoot().getProject("MyProject"); |
| try { |
| IFolder folder = project.getFolder("folder1"); |
| IFile file1 = project.getFile("file1.txt"); |
| IFile file2 = folder.getFile("file2.txt"); |
| ensureExistsInWorkspace(new IResource[] {file1, file2}, true); |
| project.setDefaultCharset("FOO", getMonitor()); |
| file1.setCharset("FRED", getMonitor()); |
| folder.setDefaultCharset("BAR", getMonitor()); |
| // move a folder inside the project and ensure its encoding is |
| // preserved |
| folder.move(project.getFullPath().append("folder2"), false, false, null); |
| folder = project.getFolder("folder2"); |
| assertEquals("1.0", "BAR", folder.getDefaultCharset()); |
| assertEquals("1.1", "BAR", folder.getFile("file2.txt").getCharset()); |
| // move a file inside the project and ensure its encoding is |
| // update accordingly |
| file2 = folder.getFile("file2.txt"); |
| file2.move(project.getFullPath().append("file2.txt"), false, false, null); |
| file2 = project.getFile("file2.txt"); |
| assertEquals("2.0", project.getDefaultCharset(), file2.getCharset()); |
| // delete a file and recreate it and ensure the encoding is not |
| // remembered |
| file1.delete(false, false, null); |
| ensureExistsInWorkspace(new IResource[] {file1}, true); |
| assertEquals("3.0", project.getDefaultCharset(), file1.getCharset()); |
| } finally { |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| } |
| |
| public void testClosingAndReopeningProject() throws CoreException { |
| IWorkspace workspace = getWorkspace(); |
| IProject project = workspace.getRoot().getProject("MyProject"); |
| try { |
| // create a project and set some explicit encodings |
| IFolder folder = project.getFolder("folder"); |
| IFile file1 = project.getFile("file1.txt"); |
| IFile file2 = folder.getFile("file2.txt"); |
| ensureExistsInWorkspace(new IResource[] {file1, file2}, true); |
| project.setDefaultCharset("FOO", getMonitor()); |
| file1.setCharset("FRED", getMonitor()); |
| folder.setDefaultCharset("BAR", getMonitor()); |
| project.close(null); |
| // now reopen the project and ensure the settings were not forgotten |
| IProject projectB = workspace.getRoot().getProject(project.getName()); |
| projectB.open(null); |
| assertExistsInWorkspace("0.9", getResourcesPreferenceFile(projectB, false)); |
| assertEquals("1.0", "FOO", projectB.getDefaultCharset()); |
| assertEquals("3.0", "FRED", projectB.getFile("file1.txt").getCharset()); |
| assertEquals("2.0", "BAR", projectB.getFolder("folder").getDefaultCharset()); |
| assertEquals("2.1", "BAR", projectB.getFolder("folder").getFile("file2.txt").getCharset()); |
| } finally { |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| } |
| |
| /** |
| * Tests Content Manager-based charset setting. |
| */ |
| public void testContentBasedCharset() throws CoreException, UnsupportedEncodingException { |
| IWorkspace workspace = getWorkspace(); |
| IProject project = workspace.getRoot().getProject("MyProject"); |
| try { |
| ensureExistsInWorkspace(project, true); |
| project.setDefaultCharset("FOO", getMonitor()); |
| IFile file = project.getFile("file.xml"); |
| assertEquals("0.9", "FOO", project.getDefaultCharset()); |
| // content-based encoding is BAR |
| ensureExistsInWorkspace(file, new ByteArrayInputStream(SAMPLE_XML_US_ASCII_ENCODING.getBytes("UTF-8"))); |
| assertEquals("1.0", "US-ASCII", file.getCharset()); |
| // content-based encoding is FRED |
| file.setContents(new ByteArrayInputStream(SAMPLE_XML_ISO_8859_1_ENCODING.getBytes("ISO-8859-1")), false, false, null); |
| assertEquals("2.0", "ISO-8859-1", file.getCharset()); |
| // content-based encoding is UTF-8 (default for XML) |
| file.setContents(new ByteArrayInputStream(SAMPLE_XML_DEFAULT_ENCODING.getBytes("UTF-8")), false, false, null); |
| assertEquals("3.0", "UTF-8", file.getCharset()); |
| // tests with BOM -BOMs are strings for convenience, encoded itno bytes using ISO-8859-1 (which handles 128-255 bytes better) |
| // tests with UTF-8 BOM |
| String UTF8_BOM = new String(IContentDescription.BOM_UTF_8, "ISO-8859-1"); |
| file.setContents(new ByteArrayInputStream((UTF8_BOM + SAMPLE_XML_DEFAULT_ENCODING).getBytes("ISO-8859-1")), false, false, null); |
| assertEquals("4.0", "UTF-8", file.getCharset()); |
| // tests with UTF-16 Little Endian BOM |
| String UTF16_LE_BOM = new String(IContentDescription.BOM_UTF_16LE, "ISO-8859-1"); |
| file.setContents(new ByteArrayInputStream((UTF16_LE_BOM + SAMPLE_XML_DEFAULT_ENCODING).getBytes("ISO-8859-1")), false, false, null); |
| assertEquals("5.0", "UTF-16", file.getCharset()); |
| // tests with UTF-16 Big Endian BOM |
| String UTF16_BE_BOM = new String(IContentDescription.BOM_UTF_16BE, "ISO-8859-1"); |
| file.setContents(new ByteArrayInputStream((UTF16_BE_BOM + SAMPLE_XML_DEFAULT_ENCODING).getBytes("ISO-8859-1")), false, false, null); |
| assertEquals("6.0", "UTF-16", file.getCharset()); |
| } finally { |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| } |
| |
| public void testDefaults() throws CoreException { |
| IProject project = null; |
| String originalCharset = ResourcesPlugin.getPlugin().getPluginPreferences().getString(ResourcesPlugin.PREF_ENCODING); |
| try { |
| IWorkspace workspace = getWorkspace(); |
| project = workspace.getRoot().getProject("MyProject"); |
| IFolder folder1 = project.getFolder("folder1"); |
| IFolder folder2 = folder1.getFolder("folder2"); |
| IFile file1 = project.getFile("file1.txt"); |
| IFile file2 = folder1.getFile("file2.txt"); |
| IFile file3 = folder2.getFile("file3.txt"); |
| ensureExistsInWorkspace(new IResource[] {file1, file2, file3}, true); |
| // project and children should be using the workspace's default now |
| assertCharsetIs("1.0", ResourcesPlugin.getEncoding(), new IResource[] {workspace.getRoot(), project, file1, folder1, file2, folder2, file3}, true); |
| assertCharsetIs("1.1", null, new IResource[] {project, file1, folder1, file2, folder2, file3}, false); |
| // sets workspace default charset |
| workspace.getRoot().setDefaultCharset("FOO", getMonitor()); |
| assertCharsetIs("2.0", "FOO", new IResource[] {workspace.getRoot(), project, file1, folder1, file2, folder2, file3}, true); |
| assertCharsetIs("2.1", null, new IResource[] {project, file1, folder1, file2, folder2, file3}, false); |
| // sets project default charset |
| project.setDefaultCharset("BAR", getMonitor()); |
| assertCharsetIs("3.0", "BAR", new IResource[] {project, file1, folder1, file2, folder2, file3}, true); |
| assertCharsetIs("3.1", null, new IResource[] {file1, folder1, file2, folder2, file3}, false); |
| assertCharsetIs("3.2", "FOO", new IResource[] {workspace.getRoot()}, true); |
| // sets folder1 default charset |
| folder1.setDefaultCharset("FRED", getMonitor()); |
| assertCharsetIs("4.0", "FRED", new IResource[] {folder1, file2, folder2, file3}, true); |
| assertCharsetIs("4.1", null, new IResource[] {file2, folder2, file3}, false); |
| assertCharsetIs("4.2", "BAR", new IResource[] {project, file1}, true); |
| // sets folder2 default charset |
| folder2.setDefaultCharset("ZOO", getMonitor()); |
| assertCharsetIs("5.0", "ZOO", new IResource[] {folder2, file3}, true); |
| assertCharsetIs("5.1", null, new IResource[] {file3}, false); |
| assertCharsetIs("5.2", "FRED", new IResource[] {folder1, file2}, true); |
| // sets file3 charset |
| file3.setCharset("ZIT", getMonitor()); |
| assertCharsetIs("6.0", "ZIT", new IResource[] {file3}, false); |
| folder2.setDefaultCharset(null, getMonitor()); |
| assertCharsetIs("7.0", folder2.getParent().getDefaultCharset(), new IResource[] {folder2}, true); |
| assertCharsetIs("7.1", null, new IResource[] {folder2}, false); |
| assertCharsetIs("7.2", "ZIT", new IResource[] {file3}, false); |
| folder1.setDefaultCharset(null, getMonitor()); |
| assertCharsetIs("8.0", folder1.getParent().getDefaultCharset(), new IResource[] {folder1, file2, folder2}, true); |
| assertCharsetIs("8.1", null, new IResource[] {folder1, file2, folder2}, false); |
| assertCharsetIs("8.2", "ZIT", new IResource[] {file3}, false); |
| project.setDefaultCharset(null, getMonitor()); |
| assertCharsetIs("9.0", project.getParent().getDefaultCharset(), new IResource[] {project, file1, folder1, file2, folder2}, true); |
| assertCharsetIs("9.1", null, new IResource[] {project, file1, folder1, file2, folder2}, false); |
| assertCharsetIs("9.2", "ZIT", new IResource[] {file3}, false); |
| workspace.getRoot().setDefaultCharset(null, getMonitor()); |
| assertCharsetIs("10.0", project.getParent().getDefaultCharset(), new IResource[] {project, file1, folder1, file2, folder2}, true); |
| assertCharsetIs("10.1", "ZIT", new IResource[] {file3}, false); |
| file3.setCharset(null, getMonitor()); |
| assertCharsetIs("11.0", ResourcesPlugin.getEncoding(), new IResource[] {workspace.getRoot(), project, file1, folder1, file2, folder2, file3}, true); |
| } finally { |
| ResourcesPlugin.getPlugin().getPluginPreferences().setValue(ResourcesPlugin.PREF_ENCODING, originalCharset); |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| } |
| |
| // check we react to content type changes |
| public void testDeltaOnContentTypeChanges() { |
| final String USER_SETTING = "USER_CHARSET"; |
| final String PROVIDER_SETTING = "PROVIDER_CHARSET"; |
| |
| // install a verifier |
| CharsetVerifier backgroundVerifier = new CharsetVerifier(CharsetVerifier.IGNORE_CREATION_THREAD); |
| getWorkspace().addResourceChangeListener(backgroundVerifier, IResourceChangeEvent.POST_CHANGE); |
| IContentTypeManager contentTypeManager = Platform.getContentTypeManager(); |
| IContentType myType = contentTypeManager.getContentType("org.eclipse.core.tests.resources.myContent2"); |
| assertNotNull("0.1", myType); |
| assertEquals("0.2", PROVIDER_SETTING, myType.getDefaultCharset()); |
| IProject project = getWorkspace().getRoot().getProject("project1"); |
| try { |
| IFolder folder1 = project.getFolder("folder1"); |
| IFile file1 = folder1.getFile("file1.txt"); |
| IFile file2 = folder1.getFile("file2.resources-mc"); |
| IFile file3 = project.getFile("file3.resources-mc"); |
| IFile file4 = project.getFile("file4.resources-mc"); |
| ensureExistsInWorkspace(new IResource[] {file1, file2, file3, file4}, true); |
| try { |
| project.setDefaultCharset("FOO", getMonitor()); |
| } catch (CoreException e) { |
| fail("1.0", e); |
| } |
| // even files with a user-set charset will appear in the delta |
| try { |
| file4.setCharset("BAR", getMonitor()); |
| } catch (CoreException e) { |
| fail("1.1", e); |
| } |
| // configure verifier |
| backgroundVerifier.reset(); |
| backgroundVerifier.addExpectedChange(new IResource[] {file2, file3, file4}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| // change content type's default charset |
| try { |
| myType.setDefaultCharset(USER_SETTING); |
| } catch (CoreException e) { |
| fail("2.0", e); |
| } |
| // ensure the property events were generated |
| assertTrue("2.1", backgroundVerifier.waitForEvent(10000)); |
| assertTrue("2.2 " + backgroundVerifier.getMessage(), backgroundVerifier.isDeltaValid()); |
| try { |
| assertEquals("3.0", USER_SETTING, file2.getCharset()); |
| assertEquals("3.1", USER_SETTING, file3.getCharset()); |
| assertEquals("3.2", "BAR", file4.getCharset()); |
| } catch (CoreException e) { |
| fail("3.9", e); |
| } |
| |
| // change back to the provider-provided default |
| // configure verifier |
| backgroundVerifier.reset(); |
| backgroundVerifier.addExpectedChange(new IResource[] {file2, file3, file4}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| // reset charset to default |
| try { |
| myType.setDefaultCharset(null); |
| } catch (CoreException e) { |
| fail("4.0", e); |
| } |
| // ensure the property events were generated |
| assertTrue("4.1", backgroundVerifier.waitForEvent(10000)); |
| assertTrue("4.2 " + backgroundVerifier.getMessage(), backgroundVerifier.isDeltaValid()); |
| try { |
| assertEquals("5.0", PROVIDER_SETTING, file2.getCharset()); |
| assertEquals("5.1", PROVIDER_SETTING, file3.getCharset()); |
| assertEquals("5.2", "BAR", file4.getCharset()); |
| } catch (CoreException e) { |
| fail("5.9", e); |
| } |
| } finally { |
| getWorkspace().removeResourceChangeListener(backgroundVerifier); |
| try { |
| myType.setDefaultCharset(null); |
| } catch (CoreException e) { |
| fail("99.0", e); |
| } |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| } |
| |
| // check preference change events are reflected in the charset settings |
| // temporarily disabled |
| public void testDeltaOnPreferenceChanges() { |
| |
| CharsetVerifier backgroundVerifier = new CharsetVerifier(CharsetVerifier.IGNORE_CREATION_THREAD); |
| getWorkspace().addResourceChangeListener(backgroundVerifier, IResourceChangeEvent.POST_CHANGE); |
| IProject project = getWorkspace().getRoot().getProject("project1"); |
| try { |
| IFolder folder1 = project.getFolder("folder1"); |
| IFile file1 = folder1.getFile("file1.txt"); |
| IFile file2 = project.getFile("file2.txt"); |
| ensureExistsInWorkspace(new IResource[] {file1, file2}, true); |
| |
| IFile resourcesPrefs = getResourcesPreferenceFile(project, false); |
| assertTrue("0.9", !resourcesPrefs.exists()); |
| |
| try { |
| file1.setCharset("CHARSET1", getMonitor()); |
| } catch (CoreException e) { |
| fail("1.0", e); |
| } |
| assertTrue("1.1", resourcesPrefs.exists()); |
| |
| backgroundVerifier.reset(); |
| backgroundVerifier.addExpectedChange(new IResource[] {project, folder1, file1, file2, resourcesPrefs, resourcesPrefs.getParent()}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| // cause a resource change event without actually changing contents |
| try { |
| resourcesPrefs.setContents(resourcesPrefs.getContents(), 0, getMonitor()); |
| } catch (CoreException e) { |
| fail("2.0", e); |
| } |
| assertTrue("2.1", backgroundVerifier.waitForEvent(10000)); |
| assertTrue("2.2 " + backgroundVerifier.getMessage(), backgroundVerifier.isDeltaValid()); |
| |
| backgroundVerifier.reset(); |
| backgroundVerifier.addExpectedChange(new IResource[] {project, folder1, file1, file2, resourcesPrefs.getParent()}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| try { |
| // delete the preferences file |
| resourcesPrefs.delete(true, getMonitor()); |
| } catch (CoreException e) { |
| fail("3.0", e); |
| } |
| assertTrue("3.1", backgroundVerifier.waitForEvent(10000)); |
| assertTrue("3.2 " + backgroundVerifier.getMessage(), backgroundVerifier.isDeltaValid()); |
| |
| } finally { |
| getWorkspace().removeResourceChangeListener(backgroundVerifier); |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| } |
| |
| /** |
| * Test the contents of the resource deltas which are generated |
| * when we make encoding changes to containers (folders, projects, root). |
| */ |
| public void testDeltasContainer() { |
| CharsetVerifier verifier = new CharsetVerifier(CharsetVerifier.IGNORE_BACKGROUND_THREAD); |
| IProject project = getWorkspace().getRoot().getProject(getUniqueString()); |
| getWorkspace().addResourceChangeListener(verifier, IResourceChangeEvent.POST_CHANGE); |
| try { |
| IFile prefs = getResourcesPreferenceFile(project, false); |
| // leaf folder |
| IFolder folder1 = project.getFolder("folder1"); |
| ensureExistsInWorkspace(new IResource[] {project, folder1}, true); |
| verifier.reset(); |
| verifier.addExpectedChange(folder1, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| verifier.addExpectedChange(new IResource[] {prefs, prefs.getParent()}, IResourceDelta.ADDED, 0); |
| try { |
| folder1.setDefaultCharset("new_charset", getMonitor()); |
| } catch (CoreException e) { |
| fail("1.0", e); |
| } |
| assertTrue("1.1." + verifier.getMessage(), verifier.isDeltaValid()); |
| |
| // folder with children |
| IFolder folder2 = folder1.getFolder("folder2"); |
| IFile file1 = folder1.getFile("file1.txt"); |
| IFile file2 = folder2.getFile("file2.txt"); |
| ensureExistsInWorkspace(new IResource[] {folder2, file1, file2}, true); |
| verifier.reset(); |
| verifier.addExpectedChange(new IResource[] {folder1, folder2, file1, file2}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| verifier.addExpectedChange(prefs.getParent(), IResourceDelta.CHANGED, 0); |
| verifier.addExpectedChange(prefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| try { |
| folder1.setDefaultCharset("a_charset", getMonitor()); |
| } catch (CoreException e) { |
| fail("2.0", e); |
| } |
| assertTrue("2.1." + verifier.getMessage(), verifier.isDeltaValid()); |
| |
| // folder w. children, some with non-inherited values |
| try { |
| // set the child to have a non-inherited value |
| folder2.setDefaultCharset("non-Default", getMonitor()); |
| } catch (CoreException e) { |
| fail("3.0", e); |
| } |
| verifier.reset(); |
| verifier.addExpectedChange(new IResource[] {folder1, file1}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| verifier.addExpectedChange(prefs.getParent(), IResourceDelta.CHANGED, 0); |
| verifier.addExpectedChange(prefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| try { |
| folder1.setDefaultCharset("newOne", getMonitor()); |
| } catch (CoreException e) { |
| fail("3.1", e); |
| } |
| assertTrue("3.2." + verifier.getMessage(), verifier.isDeltaValid()); |
| |
| // change from non-default to another non-default |
| verifier.reset(); |
| verifier.addExpectedChange(new IResource[] {folder1, file1}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| verifier.addExpectedChange(prefs.getParent(), IResourceDelta.CHANGED, 0); |
| verifier.addExpectedChange(prefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| try { |
| folder1.setDefaultCharset("newTwo", getMonitor()); |
| } catch (CoreException e) { |
| fail("4.1", e); |
| } |
| assertTrue("4.2." + verifier.getMessage(), verifier.isDeltaValid()); |
| |
| // change to default (clear it) |
| verifier.reset(); |
| verifier.addExpectedChange(new IResource[] {folder1, file1}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| verifier.addExpectedChange(prefs.getParent(), IResourceDelta.CHANGED, 0); |
| verifier.addExpectedChange(prefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| try { |
| folder1.setDefaultCharset(null, getMonitor()); |
| } catch (CoreException e) { |
| fail("5.0", e); |
| } |
| assertTrue("5.1." + verifier.getMessage(), verifier.isDeltaValid()); |
| |
| // change to default (equal to it but it doesn't inherit) |
| verifier.reset(); |
| verifier.addExpectedChange(new IResource[] {folder1, file1}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| verifier.addExpectedChange(prefs.getParent(), IResourceDelta.CHANGED, 0); |
| verifier.addExpectedChange(prefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| try { |
| folder1.setDefaultCharset(project.getDefaultCharset(), getMonitor()); |
| } catch (CoreException e) { |
| fail("6.0", e); |
| } |
| assertTrue("6.1." + verifier.getMessage(), verifier.isDeltaValid()); |
| |
| // clear all the encoding info before we start working with the project |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("7.0", e); |
| } |
| verifier.reset(); |
| verifier.addExpectedChange(new IResource[] {project, folder1, folder2, file1, file2, prefs.getParent()}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| verifier.addExpectedChange(prefs, IResourceDelta.ADDED, 0); |
| try { |
| project.setDefaultCharset("foo", getMonitor()); |
| } catch (CoreException e) { |
| fail("7.1", e); |
| } |
| assertTrue("7.2." + verifier.getMessage(), verifier.isDeltaValid()); |
| |
| // clear all the encoding info before we start working with the root |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("8.0", e); |
| } |
| verifier.reset(); |
| verifier.addExpectedChange(new IResource[] {project, folder1, folder2, file1, file2, prefs.getParent()}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| try { |
| getWorkspace().getRoot().setDefaultCharset("foo", getMonitor()); |
| } catch (CoreException e) { |
| fail("8.1", e); |
| } |
| assertTrue("8.2." + verifier.getMessage(), verifier.isDeltaValid()); |
| } finally { |
| getWorkspace().removeResourceChangeListener(verifier); |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| } |
| |
| /** |
| * Check that we are broadcasting the correct resource deltas when |
| * making encoding changes. |
| * |
| */ |
| public void testDeltasFile() { |
| IWorkspace workspace = getWorkspace(); |
| CharsetVerifier verifier = new CharsetVerifier(CharsetVerifier.IGNORE_BACKGROUND_THREAD); |
| workspace.addResourceChangeListener(verifier, IResourceChangeEvent.POST_CHANGE); |
| final IProject project = workspace.getRoot().getProject("MyProject"); |
| try { |
| IFile prefs = getResourcesPreferenceFile(project, false); |
| // File: |
| // single file |
| final IFile file1 = project.getFile("file1.txt"); |
| ensureExistsInWorkspace(file1, getRandomContents()); |
| // change from default |
| verifier.reset(); |
| verifier.addExpectedChange(file1, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| verifier.addExpectedChange(new IResource[] {prefs, prefs.getParent()}, IResourceDelta.ADDED, 0); |
| try { |
| file1.setCharset("FOO", getMonitor()); |
| } catch (CoreException e) { |
| fail("1.0.0", e); |
| } |
| assertTrue("1.0.1" + verifier.getMessage(), verifier.isDeltaValid()); |
| |
| // change to default (clear it) |
| verifier.reset(); |
| verifier.addExpectedChange(file1, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| verifier.addExpectedChange(prefs.getParent(), IResourceDelta.CHANGED, 0); |
| verifier.addExpectedChange(prefs, IResourceDelta.REMOVED, 0); |
| try { |
| file1.setCharset(null, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.1.0", e); |
| } |
| assertTrue("1.1.1" + verifier.getMessage(), verifier.isDeltaValid()); |
| |
| // change to default (equal to it but it doesn't inherit) |
| verifier.reset(); |
| verifier.addExpectedChange(file1, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| verifier.addExpectedChange(prefs.getParent(), IResourceDelta.CHANGED, 0); |
| verifier.addExpectedChange(prefs, IResourceDelta.ADDED, 0); |
| try { |
| file1.setCharset(file1.getCharset(), getMonitor()); |
| } catch (CoreException e) { |
| fail("1.2.0", e); |
| } |
| assertTrue("1.2.1" + verifier.getMessage(), verifier.isDeltaValid()); |
| |
| // change from non-default to another non-default |
| try { |
| // sets to a non-default value first |
| file1.setCharset("FOO", getMonitor()); |
| } catch (CoreException e) { |
| fail("1.3.0", e); |
| } |
| verifier.reset(); |
| verifier.addExpectedChange(file1, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| verifier.addExpectedChange(prefs.getParent(), IResourceDelta.CHANGED, 0); |
| verifier.addExpectedChange(prefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| try { |
| // sets to another non-defauilt value |
| file1.setCharset("BAR", getMonitor()); |
| } catch (CoreException e) { |
| fail("1.3.1", e); |
| } |
| assertTrue("1.3.2" + verifier.getMessage(), verifier.isDeltaValid()); |
| |
| // multiple files (same operation) |
| verifier.reset(); |
| final IFile file2 = project.getFile("file2.txt"); |
| ensureExistsInWorkspace(file2, getRandomContents()); |
| verifier.addExpectedChange(new IResource[] {file1, file2}, IResourceDelta.CHANGED, IResourceDelta.ENCODING); |
| verifier.addExpectedChange(prefs.getParent(), IResourceDelta.CHANGED, 0); |
| verifier.addExpectedChange(prefs, IResourceDelta.CHANGED, IResourceDelta.CONTENT); |
| try { |
| workspace.run((IWorkspaceRunnable) monitor -> { |
| file1.setCharset("FOO", getMonitor()); |
| file2.setCharset("FOO", getMonitor()); |
| }, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.4.0", e); |
| } |
| assertTrue("1.4.1" + verifier.getMessage(), verifier.isDeltaValid()); |
| } finally { |
| getWorkspace().removeResourceChangeListener(verifier); |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| } |
| |
| public void testFileCreation() throws CoreException { |
| IWorkspace workspace = getWorkspace(); |
| IProject project = workspace.getRoot().getProject("MyProject"); |
| try { |
| IFolder folder = project.getFolder("folder"); |
| IFile file1 = project.getFile("file1.txt"); |
| IFile file2 = folder.getFile("file2.txt"); |
| ensureExistsInWorkspace(new IResource[] {file1, file2}, true); |
| assertDoesNotExistInWorkspace("1.0", getResourcesPreferenceFile(project, false)); |
| project.setDefaultCharset("FOO", getMonitor()); |
| assertExistsInWorkspace("2.0", getResourcesPreferenceFile(project, false)); |
| project.setDefaultCharset(null, getMonitor()); |
| assertDoesNotExistInWorkspace("3.0", getResourcesPreferenceFile(project, false)); |
| file1.setCharset("FRED", getMonitor()); |
| assertExistsInWorkspace("4.0", getResourcesPreferenceFile(project, false)); |
| folder.setDefaultCharset("BAR", getMonitor()); |
| assertExistsInWorkspace("5.0", getResourcesPreferenceFile(project, false)); |
| file1.setCharset(null, getMonitor()); |
| assertExistsInWorkspace("6.0", getResourcesPreferenceFile(project, false)); |
| folder.setDefaultCharset(null, getMonitor()); |
| assertDoesNotExistInWorkspace("7.0", getResourcesPreferenceFile(project, false)); |
| } finally { |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| } |
| |
| /** |
| * See enhancement request 60636. |
| */ |
| public void testGetCharsetFor() throws CoreException { |
| IProject project = null; |
| try { |
| IContentTypeManager contentTypeManager = Platform.getContentTypeManager(); |
| // IContentType text = contentTypeManager.getContentType("org.eclipse.core.runtime.text"); |
| IContentType xml = contentTypeManager.getContentType("org.eclipse.core.runtime.xml"); |
| |
| IWorkspace workspace = getWorkspace(); |
| project = workspace.getRoot().getProject("MyProject"); |
| IFile oldFile = project.getFile("oldfile.xml"); |
| IFile newXMLFile = project.getFile("newfile.xml"); |
| IFile newTXTFile = project.getFile("newfile.txt"); |
| IFile newRandomFile = project.getFile("newFile." + (long) (Math.random() * (Long.MAX_VALUE))); |
| ensureExistsInWorkspace(oldFile, SAMPLE_XML_DEFAULT_ENCODING); |
| // sets project default charset |
| project.setDefaultCharset("BAR", getMonitor()); |
| oldFile.setCharset("FOO", getMonitor()); |
| // project and non-existing file share the same encoding |
| assertCharsetIs("0.1", "BAR", new IResource[] {project, newXMLFile, newTXTFile, newRandomFile}, true); |
| // existing file has encoding determined by user |
| assertCharsetIs("0.2", "FOO", new IResource[] {oldFile}, true); |
| |
| // for an existing file, user set charset will prevail (if any) |
| assertEquals("1.0", "FOO", oldFile.getCharsetFor(getTextContents(""))); |
| assertEquals("1.1", "FOO", oldFile.getCharsetFor(getTextContents(SAMPLE_XML_DEFAULT_ENCODING))); |
| |
| // for a non-existing file, or for a file that exists but does not have a user set charset, the content type (if any) rules |
| assertEquals("2.0", xml.getDefaultCharset(), newXMLFile.getCharsetFor(getTextContents(""))); |
| assertEquals("2.1", xml.getDefaultCharset(), newXMLFile.getCharsetFor(getTextContents(SAMPLE_XML_DEFAULT_ENCODING))); |
| assertEquals("2.2", "US-ASCII", newXMLFile.getCharsetFor(getTextContents(SAMPLE_XML_US_ASCII_ENCODING))); |
| oldFile.setCharset(null, getMonitor()); |
| assertEquals("2.3", xml.getDefaultCharset(), oldFile.getCharsetFor(getTextContents(""))); |
| assertEquals("2.4", xml.getDefaultCharset(), oldFile.getCharsetFor(getTextContents(SAMPLE_XML_DEFAULT_ENCODING))); |
| assertEquals("2.5", "US-ASCII", oldFile.getCharsetFor(getTextContents(SAMPLE_XML_US_ASCII_ENCODING))); |
| |
| // if the content type has no default charset, or the file has no known content type, fallback to parent default charset |
| assertEquals("3.0", project.getDefaultCharset(), newTXTFile.getCharsetFor(getTextContents(""))); |
| assertEquals("3.1", project.getDefaultCharset(), newRandomFile.getCharsetFor(getTextContents(""))); |
| } finally { |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| |
| } |
| |
| /** |
| * Moves a project and ensures the charsets are preserved. |
| */ |
| public void testMovingProject() throws CoreException { |
| IWorkspace workspace = getWorkspace(); |
| IProject project1 = workspace.getRoot().getProject("Project1"); |
| IProject project2 = null; |
| try { |
| IFolder folder = project1.getFolder("folder1"); |
| IFile file1 = project1.getFile("file1.txt"); |
| IFile file2 = folder.getFile("file2.txt"); |
| ensureExistsInWorkspace(new IResource[] {file1, file2}, true); |
| project1.setDefaultCharset("FOO", getMonitor()); |
| folder.setDefaultCharset("BAR", getMonitor()); |
| |
| assertEquals("1.0", "BAR", folder.getDefaultCharset()); |
| assertEquals("1.1", "BAR", file2.getCharset()); |
| assertEquals("1.2", "FOO", file1.getCharset()); |
| assertEquals("1.3", "FOO", project1.getDefaultCharset()); |
| |
| // move project and ensures charsets settings are preserved |
| project1.move(new Path("Project2"), false, null); |
| project2 = workspace.getRoot().getProject("Project2"); |
| folder = project2.getFolder("folder1"); |
| file1 = project2.getFile("file1.txt"); |
| file2 = folder.getFile("file2.txt"); |
| assertEquals("2.0", "BAR", folder.getDefaultCharset()); |
| assertEquals("2.1", "BAR", file2.getCharset()); |
| assertEquals("2.2", "FOO", project2.getDefaultCharset()); |
| assertEquals("2.3", "FOO", file1.getCharset()); |
| } finally { |
| try { |
| clearAllEncodings(project1); |
| clearAllEncodings(project2); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| } |
| |
| /** |
| * Two things to test here: |
| * - non-existing resources default to the parent's default charset; |
| * - cannot set the charset for a non-existing resource (exception is thrown). |
| */ |
| public void testNonExistingResource() throws CoreException { |
| IWorkspace workspace = getWorkspace(); |
| IProject project = workspace.getRoot().getProject("MyProject"); |
| try { |
| try { |
| project.setDefaultCharset("FOO", getMonitor()); |
| fail("1.0"); |
| } catch (CoreException e) { |
| // expected, project does not exist yet |
| assertEquals("1.1", IResourceStatus.RESOURCE_NOT_FOUND, e.getStatus().getCode()); |
| } |
| ensureExistsInWorkspace(project, true); |
| project.setDefaultCharset("FOO", getMonitor()); |
| IFile file = project.getFile("file.xml"); |
| assertDoesNotExistInWorkspace("2.0", file); |
| assertEquals("2.2", "FOO", file.getCharset()); |
| try { |
| file.setCharset("BAR", getMonitor()); |
| fail("2.4"); |
| } catch (CoreException e) { |
| // expected, file does not exist yet |
| assertEquals("2.6", IResourceStatus.RESOURCE_NOT_FOUND, e.getStatus().getCode()); |
| } |
| ensureExistsInWorkspace(file, true); |
| file.setCharset("BAR", getMonitor()); |
| assertEquals("2.8", "BAR", file.getCharset()); |
| file.delete(IResource.NONE, null); |
| assertDoesNotExistInWorkspace("2.10", file); |
| assertEquals("2.11", "FOO", file.getCharset()); |
| } finally { |
| try { |
| clearAllEncodings(project); |
| } catch (CoreException e) { |
| fail("99.9", e); |
| } |
| } |
| } |
| |
| public void testBug464072() throws CoreException { |
| getResourcesPreferences().putBoolean(ResourcesPlugin.PREF_LIGHTWEIGHT_AUTO_REFRESH, true); |
| IWorkspace workspace = getWorkspace(); |
| IProject project = workspace.getRoot().getProject(getUniqueString()); |
| IFile file = project.getFile("file.txt"); |
| ensureExistsInWorkspace(file, true); |
| file.getLocation().toFile().delete(); |
| try { |
| file.getContentDescription(); |
| fail("1.2 - should have failed"); |
| } catch (CoreException e) { |
| // Ok, the resource does not exist. |
| assertEquals("1.3", IResourceStatus.RESOURCE_NOT_FOUND, e.getStatus().getCode()); |
| } |
| } |
| } |
