| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.netbeans.core.validation; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.PrintStream; |
| import java.net.URL; |
| import java.net.URLConnection; |
| import java.text.MessageFormat; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.MissingResourceException; |
| import java.util.Properties; |
| import java.util.Set; |
| import java.util.TreeMap; |
| import java.util.TreeSet; |
| import java.util.jar.Manifest; |
| import java.util.logging.Handler; |
| import java.util.logging.Level; |
| import java.util.logging.LogRecord; |
| import java.util.logging.Logger; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| import javax.swing.Action; |
| import junit.framework.Test; |
| import junit.framework.TestSuite; |
| import org.netbeans.core.startup.layers.LayerCacheManager; |
| import org.netbeans.junit.NbModuleSuite; |
| import org.netbeans.junit.NbTestCase; |
| import org.netbeans.junit.Log; |
| import org.netbeans.junit.RandomlyFails; |
| import org.openide.cookies.InstanceCookie; |
| import org.openide.filesystems.FileObject; |
| import org.openide.filesystems.FileSystem; |
| import org.openide.filesystems.FileUtil; |
| import org.openide.filesystems.MultiFileSystem; |
| import org.openide.filesystems.XMLFileSystem; |
| import org.openide.loaders.DataFolder; |
| import org.openide.loaders.DataObject; |
| import org.openide.loaders.DataShadow; |
| import org.openide.modules.Dependency; |
| import org.openide.util.Enumerations; |
| import org.openide.util.Lookup; |
| import org.openide.util.Mutex; |
| import org.openide.util.NbCollections; |
| |
| /** Checks consistency of System File System contents. |
| */ |
| public class ValidateLayerConsistencyTest extends NbTestCase { |
| |
| static { |
| System.setProperty("java.awt.headless", "true"); |
| // System.setProperty("org.openide.util.lookup.level", "FINE"); |
| } |
| |
| private static final String SFS_LB = "SystemFileSystem.localizingBundle"; |
| |
| private ClassLoader contextClassLoader; |
| |
| public ValidateLayerConsistencyTest(String name) { |
| super (name); |
| } |
| |
| public @Override void setUp() throws Exception { |
| clearWorkDir(); |
| Mutex.EVENT.readAccess(new Mutex.Action<Void>() { |
| public @Override Void run() { |
| contextClassLoader = Thread.currentThread().getContextClassLoader(); |
| Thread.currentThread().setContextClassLoader(Lookup.getDefault().lookup(ClassLoader.class)); |
| return null; |
| } |
| }); |
| } |
| |
| public @Override void tearDown() { |
| Mutex.EVENT.readAccess(new Mutex.Action<Void>() { |
| public @Override Void run() { |
| Thread.currentThread().setContextClassLoader(contextClassLoader); |
| return null; |
| } |
| }); |
| } |
| |
| protected @Override boolean runInEQ() { |
| return true; |
| } |
| |
| public static Test suite() { |
| TestSuite suite = new TestSuite(); |
| suite.addTest(NbModuleSuite.createConfiguration(ValidateLayerConsistencyTest.class). |
| clusters("(?!ergonomics).*").enableClasspathModules(false).enableModules(".*").gui(false).suite()); |
| suite.addTest(NbModuleSuite.createConfiguration(ValidateLayerConsistencyTest.class). |
| clusters("platform|ide").enableClasspathModules(false).enableModules(".*").gui(false).suite()); |
| return suite; |
| } |
| |
| private List<String> failures = new ArrayList<>(); |
| |
| private String appendFailure(String message, Collection<String> warnings) { |
| if (warnings.isEmpty()) { |
| return null; |
| } |
| StringBuilder b = new StringBuilder(message); |
| for (String warning : new TreeSet<String>(warnings)) { |
| b.append('\n').append(warning); |
| } |
| String s = b.toString(); |
| failures.add(s); |
| return s; |
| } |
| |
| private void assertNoFailures() { |
| if (failures.isEmpty()) { |
| return; |
| } |
| fail(String.join("", failures)); |
| } |
| |
| private void assertNoErrors(String message, Collection<String> warnings) { |
| String s = appendFailure(message, warnings); |
| if (s == null) { |
| return; |
| } |
| fail(s); |
| } |
| |
| /* Causes mysterious failure in otherwise OK-looking UI/Runtime/org-netbeans-modules-db-explorer-nodes-RootNode.instance: |
| @Override |
| protected Level logLevel() { |
| return Level.FINER; |
| } |
| */ |
| |
| /** whether an attribute will be handled in testInstantiateAllInstances anyway */ |
| private static boolean isInstanceAttribute(String attributeName) { |
| if (attributeName.equals("instanceCreate")) { |
| return true; |
| } |
| if (attributeName.equals("component")) { |
| return true; // probably being used by TopComponent.openAction |
| } |
| return false; |
| } |
| |
| public void testAreAttributesFine () { |
| List<String> errors = new ArrayList<String>(); |
| |
| FileObject root = FileUtil.getConfigRoot(); |
| Enumeration<? extends FileObject> files = Enumerations.concat(Enumerations.singleton(root), root.getChildren(true)); |
| while (files.hasMoreElements()) { |
| FileObject fo = files.nextElement(); |
| |
| if ( |
| "Keymaps/NetBeans/D-BACK_QUOTE.shadow".equals(fo.getPath()) || |
| "Keymaps/NetBeans55/D-BACK_QUOTE.shadow".equals(fo.getPath()) || |
| "Keymaps/Emacs/D-BACK_QUOTE.shadow".equals(fo.getPath()) |
| ) { |
| // #46753 |
| continue; |
| } |
| if ( |
| "Services/Browsers/FirefoxBrowser.settings".equals(fo.getPath()) || |
| "Services/Browsers/MozillaBrowser.settings".equals(fo.getPath()) || |
| "Services/Browsers/NetscapeBrowser.settings".equals(fo.getPath()) |
| ) { |
| // #161784 |
| continue; |
| } |
| |
| Enumeration<String> attrs = fo.getAttributes(); |
| while (attrs.hasMoreElements()) { |
| String name = attrs.nextElement(); |
| |
| if (isInstanceAttribute(name)) { |
| continue; |
| } |
| |
| if (name.indexOf('\\') != -1) { |
| errors.add("File: " + fo.getPath() + " attribute name must not contain backslashes: " + name); |
| } |
| |
| Object attr = fo.getAttribute(name); |
| if (attr == null) { |
| CharSequence warning = Log.enable("", Level.WARNING); |
| if ( |
| fo.getAttribute("class:" + name) != null && |
| fo.getAttribute(name) == null && |
| warning.length() == 0 |
| ) { |
| // ok, factory method returned null |
| continue; |
| } |
| |
| errors.add("File: " + fo.getPath() + " attribute name: " + name); |
| } |
| |
| if (attr instanceof URL) { |
| URL u = (URL) attr; |
| int read = -1; |
| try { |
| read = u.openStream().read(new byte[4096]); |
| } catch (IOException ex) { |
| errors.add(fo.getPath() + ": " + ex.getMessage()); |
| } |
| if (read <= 0) { |
| errors.add("URL resource does not exist: " + fo.getPath() + " attr: " + name + " value: " + attr); |
| } |
| } |
| |
| } |
| } |
| |
| assertNoErrors("Some attributes in files are unreadable", errors); |
| } |
| |
| public void testValidShadows () { |
| // might be better to move into editor/options tests as it is valid only if there are options |
| List<String> errors = new ArrayList<String>(); |
| |
| FileObject root = FileUtil.getConfigRoot(); |
| |
| Enumeration<? extends FileObject> en = root.getChildren(true); |
| int cnt = 0; |
| while (en.hasMoreElements()) { |
| FileObject fo = en.nextElement(); |
| cnt++; |
| |
| // XXX #16761 Removing attr in MFO causes storing special-null value even in unneeded cases. |
| // When the issue is fixed remove this hack. |
| if("Windows2/Modes/debugger".equals(fo.getPath()) // NOI18N |
| || "Windows2/Modes/explorer".equals(fo.getPath())) { // NOI18N |
| continue; |
| } |
| |
| if ( |
| "Keymaps/NetBeans/D-BACK_QUOTE.shadow".equals(fo.getPath()) || |
| "Keymaps/NetBeans55/D-BACK_QUOTE.shadow".equals(fo.getPath()) || |
| "Keymaps/Emacs/D-BACK_QUOTE.shadow".equals(fo.getPath()) |
| ) { |
| // #46753 |
| continue; |
| } |
| |
| try { |
| DataObject obj = DataObject.find (fo); |
| DataShadow ds = obj.getLookup().lookup(DataShadow.class); |
| if (ds != null) { |
| Object o = ds.getOriginal(); |
| if (o == null) { |
| errors.add("File " + fo + " has no original."); |
| } |
| } |
| else if ("shadow".equals(fo.getExt())) { |
| errors.add("File " + fo + " is not a valid DataShadow."); |
| } |
| } catch (Exception ex) { |
| ex.printStackTrace(); |
| errors.add ("File " + fo + " threw " + ex); |
| } |
| } |
| |
| assertNoErrors("Some shadow files in NetBeans profile are broken", errors); |
| |
| if (ValidateLayerConsistencyTest.class.getClassLoader() == ClassLoader.getSystemClassLoader()) { |
| // do not check the count as this probably means we are running |
| // plain Unit test and not inside the IDE mode |
| return; |
| } |
| |
| |
| if (cnt == 0) { |
| fail("No file objects on system file system!"); |
| } |
| } |
| |
| @RandomlyFails |
| public void testContentCanBeRead () { |
| List<String> errors = new ArrayList<String>(); |
| byte[] buffer = new byte[4096]; |
| |
| Enumeration<? extends FileObject> files = FileUtil.getConfigRoot().getChildren(true); |
| while (files.hasMoreElements()) { |
| FileObject fo = files.nextElement(); |
| |
| if (!fo.isData ()) { |
| continue; |
| } |
| long size = fo.getSize(); |
| |
| try { |
| long read = 0; |
| InputStream is = fo.getInputStream(); |
| try { |
| for (;;) { |
| int len = is.read (buffer); |
| if (len == -1) { |
| break; |
| } |
| read += len; |
| } |
| } finally { |
| is.close (); |
| } |
| |
| if (size != -1) { |
| assertEquals ("The amount of data in stream is the same as the length", size, read); |
| } |
| |
| } catch (IOException ex) { |
| ex.printStackTrace(); |
| errors.add ("File " + fo + " cannot be read: " + ex); |
| } |
| } |
| |
| assertNoErrors("Some files are unreadable", errors); |
| } |
| |
| public void testInstantiateAllInstances () { |
| List<String> errors = new ArrayList<String>(); |
| |
| Enumeration<? extends FileObject> files = FileUtil.getConfigRoot().getChildren(true); |
| while (files.hasMoreElements()) { |
| FileObject fo = files.nextElement(); |
| |
| if (skipFile(fo)) { |
| continue; |
| } |
| |
| try { |
| DataObject obj = DataObject.find (fo); |
| InstanceCookie ic = obj.getLookup().lookup(InstanceCookie.class); |
| if (ic != null) { |
| Object o = ic.instanceCreate (); |
| if (fo.getPath().matches("Services/.+[.]instance")) { |
| String instanceOf = (String) fo.getAttribute("instanceOf"); |
| if (instanceOf == null) { |
| errors.add("File " + fo.getPath() + " should declare instanceOf"); |
| } else if (o != null) { |
| for (String piece : instanceOf.split(", ?")) { |
| if (!Class.forName(piece, true, Lookup.getDefault().lookup(ClassLoader.class)).isInstance(o)) { |
| errors.add("File " + fo.getPath() + " claims to be a " + piece + " but is not (instance of " + o.getClass() + ")"); |
| } |
| } |
| } |
| } else if (fo.getPath().matches("Services/.+[.]settings")) { |
| if (!fo.asText().contains("<instanceof")) { |
| errors.add("File " + fo.getPath() + " should declare <instanceof class=\"...\"/>"); |
| } |
| // XXX test assignability here too, perhaps (but only used in legacy code) |
| } |
| } |
| } catch (Exception ex) { |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| PrintStream ps = new PrintStream(baos); |
| ex.printStackTrace(ps); |
| ps.flush(); |
| errors.add( |
| "File " + fo.getPath() + |
| "\nRead from: " + Arrays.toString((Object[])fo.getAttribute("layers")) + |
| "\nthrew: " + baos); |
| } |
| } |
| |
| assertNoErrors("Some instances cannot be created", errors); |
| } |
| |
| public void testActionInstancesOnlyInActionsFolder() { |
| List<String> errors = new ArrayList<String>(); |
| |
| Enumeration<? extends FileObject> files = FileUtil.getConfigRoot().getChildren(true); |
| FILE: while (files.hasMoreElements()) { |
| FileObject fo = files.nextElement(); |
| |
| if (skipFile(fo)) { |
| continue; |
| } |
| |
| try { |
| DataObject obj = DataObject.find (fo); |
| InstanceCookie ic = obj.getLookup().lookup(InstanceCookie.class); |
| if (ic == null) { |
| continue; |
| } |
| Object o; |
| try { |
| o = ic.instanceCreate(); |
| } catch (ClassNotFoundException ok) { |
| // wrong instances are catched by another test |
| continue; |
| } |
| if (!(o instanceof Action)) { |
| continue; |
| } |
| if (fo.hasExt("xml")) { |
| continue; |
| } |
| if (fo.getPath().startsWith("Actions/")) { |
| continue; |
| } |
| if (fo.getPath().startsWith("Editors/")) { |
| // editor is a bit different world |
| continue; |
| } |
| if (fo.getPath().startsWith("Databases/Explorer/")) { |
| // db explorer actions shall not influence start |
| // => let them be for now. |
| continue; |
| } |
| if (fo.getPath().startsWith("WelcomePage/")) { |
| // welcome screen actions are not intended for end user |
| continue; |
| } |
| if (fo.getPath().startsWith("Projects/org-netbeans-modules-mobility-project/Actions/")) { |
| // I am not sure what mobility is doing, but |
| // I guess I do not need to care |
| continue; |
| } |
| if (fo.getPath().startsWith("NativeProjects/Actions/")) { |
| // XXX should perhaps be replaced |
| continue; |
| } |
| if (fo.getPath().startsWith("contextmenu/uml/")) { |
| // UML is not the most important thing to fix |
| continue; |
| } |
| if (fo.getPath().equals("Menu/Help/org-netbeans-modules-j2ee-blueprints-ShowBluePrintsAction.instance")) { |
| // action included in some binary blob |
| continue; |
| } |
| if (Boolean.TRUE.equals(fo.getAttribute("misplaced.action.allowed"))) { |
| // it seems necessary some actions to stay outside |
| // of the Actions folder |
| continue; |
| } |
| if (fo.hasExt("shadow")) { |
| o = fo.getAttribute("originalFile"); |
| if (o instanceof String) { |
| String origF = o.toString().replaceFirst("\\/*", ""); |
| if (origF.startsWith("Actions/")) { |
| continue; |
| } |
| if (origF.startsWith("Editors/")) { |
| continue; |
| } |
| } |
| } |
| errors.add("File " + fo.getPath() + " represents an action which is not in Actions/ subfolder. Provided by " + Arrays.toString((Object[])fo.getAttribute("layers"))); |
| } catch (Exception ex) { |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| PrintStream ps = new PrintStream(baos); |
| ex.printStackTrace(ps); |
| ps.flush(); |
| errors.add ("File " + fo.getPath() + " threw: " + baos); |
| } |
| } |
| |
| assertNoErrors(errors.size() + " actions is not registered properly", errors); |
| } |
| |
| public void testLayerOverrides() throws Exception { |
| ClassLoader l = Lookup.getDefault().lookup(ClassLoader.class); |
| assertNotNull ("In the IDE mode, there always should be a classloader", l); |
| |
| class ContentAndAttrs { |
| final byte[] contents; |
| final Map<String,Object> attrs; |
| private final URL layerURL; |
| ContentAndAttrs(byte[] contents, Map<String,Object> attrs, URL layerURL) { |
| this.contents = contents; |
| this.attrs = attrs; |
| this.layerURL = layerURL; |
| } |
| public @Override String toString() { |
| return "ContentAndAttrs[contents=" + Arrays.toString(contents) + ",attrs=" + attrs + ";from=" + layerURL + "]"; |
| } |
| public @Override int hashCode() { |
| return Arrays.hashCode(contents) ^ attrs.hashCode(); |
| } |
| public @Override boolean equals(Object o) { |
| if (!(o instanceof ContentAndAttrs)) { |
| return false; |
| } |
| ContentAndAttrs caa = (ContentAndAttrs) o; |
| return Arrays.equals(contents, caa.contents) && attrs.equals(caa.attrs); |
| } |
| } |
| Map</* path */String,Map</* owner */String,ContentAndAttrs>> files = new TreeMap<String,Map<String,ContentAndAttrs>>(); |
| Map</* path */String,Map</* attr name */String,Map</* module name */String,/* attr value */Object>>> folderAttributes = |
| new TreeMap<String,Map<String,Map<String,Object>>>(); |
| Map<String,Set<String>> directDeps = new HashMap<String,Set<String>>(); |
| StringBuffer sb = new StringBuffer(); |
| Map<String,URL> hiddenFiles = new HashMap<String, URL>(); |
| Set<String> allFiles = new HashSet<String>(); |
| final String suffix = "_hidden"; |
| |
| Enumeration<URL> en = l.getResources("META-INF/MANIFEST.MF"); |
| while (en.hasMoreElements ()) { |
| URL u = en.nextElement(); |
| InputStream is = u.openStream(); |
| Manifest mf; |
| try { |
| mf = new Manifest(is); |
| } finally { |
| is.close(); |
| } |
| String module = mf.getMainAttributes ().getValue ("OpenIDE-Module"); |
| if (module == null) { |
| continue; |
| } |
| String depsS = mf.getMainAttributes().getValue("OpenIDE-Module-Module-Dependencies"); |
| if (depsS != null) { |
| Set<String> deps = new HashSet<String>(); |
| for (Dependency d : Dependency.create(Dependency.TYPE_MODULE, depsS)) { |
| deps.add(d.getName().replaceFirst("/.+$", "")); |
| } |
| directDeps.put(module, deps); |
| } |
| for (boolean generated : new boolean[] {false, true}) { |
| String layer; |
| if (generated) { |
| layer = "META-INF/generated-layer.xml"; |
| } else { |
| layer = mf.getMainAttributes ().getValue ("OpenIDE-Module-Layer"); |
| if (layer == null) { |
| continue; |
| } |
| } |
| |
| URL base = new URL(u, "../"); |
| URL layerURL = new URL(base, layer); |
| URLConnection connect; |
| try { |
| connect = layerURL.openConnection(); |
| connect.connect(); |
| } catch (FileNotFoundException x) { |
| if (generated) { |
| continue; |
| } else { |
| throw x; |
| } |
| } |
| connect.setDefaultUseCaches (false); |
| FileSystem fs = new XMLFileSystem(layerURL); |
| |
| Enumeration<? extends FileObject> all = fs.getRoot().getChildren(true); |
| while (all.hasMoreElements ()) { |
| FileObject fo = all.nextElement (); |
| String simplePath = fo.getPath(); |
| |
| if (simplePath.endsWith(suffix)) { |
| hiddenFiles.put(simplePath, layerURL); |
| } else { |
| allFiles.add(simplePath); |
| } |
| |
| Number weight = (Number) fo.getAttribute("weight"); |
| // XXX if weight != null, test that it is actually overriding something or being overridden |
| String weightedPath = weight == null ? simplePath : simplePath + "#" + weight; |
| |
| Map<String,Object> attributes = getAttributes(fo, base); |
| |
| if (fo.isFolder()) { |
| for (Map.Entry<String,Object> attr : attributes.entrySet()) { |
| Map<String,Map<String,Object>> m1 = folderAttributes.get(weightedPath); |
| if (m1 == null) { |
| m1 = new TreeMap<String,Map<String,Object>>(); |
| folderAttributes.put(weightedPath, m1); |
| } |
| Map<String,Object> m2 = m1.get(attr.getKey()); |
| if (m2 == null) { |
| m2 = new TreeMap<String,Object>(); |
| m1.put(attr.getKey(), m2); |
| } |
| m2.put(module, attr.getValue()); |
| } |
| continue; |
| } |
| |
| Map<String,ContentAndAttrs> overrides = files.get(weightedPath); |
| if (overrides == null) { |
| overrides = new TreeMap<String,ContentAndAttrs>(); |
| files.put(weightedPath, overrides); |
| } |
| try { |
| overrides.put(module, new ContentAndAttrs(fo.asBytes(), attributes, layerURL)); |
| } catch (IOException ex) { |
| // will be reported by a different test |
| } |
| } |
| // make sure the filesystem closes the stream |
| connect.getInputStream ().close (); |
| } |
| } |
| assertFalse("At least one layer file is usually used", allFiles.isEmpty()); |
| |
| for (Map.Entry<String,Map<String,ContentAndAttrs>> e : files.entrySet()) { |
| Map<String,ContentAndAttrs> overrides = e.getValue(); |
| if (overrides.size() == 1) { |
| continue; |
| } |
| Set<String> overriders = overrides.keySet(); |
| String file = e.getKey(); |
| |
| if (new HashSet<ContentAndAttrs>(overrides.values()).size() == 1) { |
| // All the same. Check whether these are parallel declarations (e.g. CND debugger vs. Java debugger), or vertical. |
| for (String overrider : overriders) { |
| Set<String> deps = new HashSet<String>(directDeps.get(overrider)); |
| deps.retainAll(overriders); |
| if (!deps.isEmpty()) { |
| sb.append(file).append(" is pointlessly overridden in ").append(overrider). |
| append(" relative to ").append(deps.iterator().next()).append('\n'); |
| } |
| } |
| continue; |
| } |
| |
| sb.append(file).append(" is provided by: ").append(overriders).append('\n'); |
| for (Map.Entry<String,ContentAndAttrs> entry : overrides.entrySet()) { |
| ContentAndAttrs contentAttrs = entry.getValue(); |
| sb.append(" ").append(entry.getKey()).append(": content = '").append(new String(contentAttrs.contents)). |
| append("', attributes = ").append(contentAttrs.attrs).append("\n"); |
| } |
| } |
| |
| for (Map.Entry<String,Map<String,Map<String,Object>>> entry1 : folderAttributes.entrySet()) { |
| for (Map.Entry<String,Map<String,Object>> entry2 : entry1.getValue().entrySet()) { |
| if (new HashSet<Object>(entry2.getValue().values()).size() > 1) { |
| sb.append("Some modules conflict on the definition of ").append(entry2.getKey()).append(" for "). |
| append(entry1.getKey()).append(": ").append(entry2.getValue()).append("\n"); |
| } |
| } |
| } |
| |
| if (sb.length () > 0) { |
| fail("Some modules override some files without using the weight attribute correctly\n" + sb); |
| } |
| |
| |
| for (Map.Entry<String, URL> e : hiddenFiles.entrySet()) { |
| String p = e.getKey().substring(0, e.getKey().length() - suffix.length()); |
| if (allFiles.contains(p)) { |
| continue; |
| } |
| sb.append("file ").append(e.getKey()).append(" from ").append(e.getValue()).append(" does not hide any other file\n"); |
| } |
| |
| if (sb.length () > 0) { |
| fail ("There are some useless hidden files\n" + sb); |
| } |
| } |
| |
| /* Too many failures to solve right now. |
| public void testLocalizingBundles() throws Exception { |
| StringBuilder sb = new StringBuilder(); |
| for (URL u : NbCollections.iterable(Lookup.getDefault().lookup(ClassLoader.class).getResources("META-INF/MANIFEST.MF"))) { |
| String layer; |
| InputStream is = u.openStream(); |
| try { |
| layer = new Manifest(is).getMainAttributes().getValue("OpenIDE-Module-Layer"); |
| if (layer == null) { |
| continue; |
| } |
| } finally { |
| is.close(); |
| } |
| URL base = new URL(u, "../"); |
| URL layerURL = new URL(base, layer); |
| URLConnection connect = layerURL.openConnection(); |
| connect.setDefaultUseCaches(false); |
| for (FileObject fo : NbCollections.iterable(new XMLFileSystem(layerURL).getRoot().getChildren(true))) { |
| Object v = getAttributes(fo, base).get(SFS_LB); |
| if (v instanceof Exception) { |
| sb.append(layerURL).append(": ").append(v).append("\n"); |
| } |
| } |
| } |
| if (sb.length() > 0) { |
| fail("Some localizing bundle declarations are wrong\n" + sb); |
| } |
| } |
| */ |
| |
| public void testNoWarningsFromLayerParsing() throws Exception { |
| ClassLoader l = Lookup.getDefault().lookup(ClassLoader.class); |
| assertNotNull ("In the IDE mode, there always should be a classloader", l); |
| |
| List<URL> urls = new ArrayList<URL>(); |
| Enumeration<URL> en = l.getResources("META-INF/MANIFEST.MF"); |
| while (en.hasMoreElements ()) { |
| URL u = en.nextElement(); |
| InputStream is = u.openStream(); |
| Manifest mf; |
| try { |
| mf = new Manifest(is); |
| } finally { |
| is.close(); |
| } |
| String module = mf.getMainAttributes ().getValue ("OpenIDE-Module"); |
| if (module == null) { |
| continue; |
| } |
| String layer = mf.getMainAttributes ().getValue ("OpenIDE-Module-Layer"); |
| if (layer == null) { |
| continue; |
| } |
| URL layerURL = new URL(u, "../" + layer); |
| urls.add(layerURL); |
| } |
| |
| File cacheDir; |
| File workDir = getWorkDir(); |
| int i = 0; |
| do { |
| cacheDir = new File(workDir, "layercache"+i); |
| i++; |
| } while (!cacheDir.mkdir()); |
| System.setProperty("netbeans.user", cacheDir.getPath()); |
| |
| LayerCacheManager bcm = LayerCacheManager.manager(true); |
| Logger err = Logger.getLogger("org.netbeans.core.projects.cache"); |
| TestHandler h = new TestHandler(); |
| err.addHandler(h); |
| ByteArrayOutputStream os = new ByteArrayOutputStream(); |
| bcm.store(bcm.createEmptyFileSystem(), urls, os); |
| assertNoErrors("No errors or warnings during layer parsing", h.errors); |
| } |
| |
| private static class TestHandler extends Handler { |
| List<String> errors = new ArrayList<String>(); |
| |
| TestHandler () {} |
| |
| public @Override void publish(LogRecord rec) { |
| if (Level.WARNING.equals(rec.getLevel()) || Level.SEVERE.equals(rec.getLevel())) { |
| errors.add(MessageFormat.format(rec.getMessage(), rec.getParameters())); |
| } |
| } |
| |
| List<String> errors() { |
| return errors; |
| } |
| |
| public @Override void flush() {} |
| |
| public @Override void close() throws SecurityException {} |
| } |
| |
| public void testFolderOrdering() throws Exception { |
| TestHandler h = new TestHandler(); |
| Logger.getLogger("org.openide.filesystems.Ordering").addHandler(h); |
| Set<List<String>> editorMultiFolders = new HashSet<List<String>>(); |
| Pattern editorFolder = Pattern.compile("Editors/(application|text)/([^/]+)(/.+|$)"); |
| Enumeration<? extends FileObject> files = FileUtil.getConfigRoot().getChildren(true); |
| while (files.hasMoreElements()) { |
| FileObject fo = files.nextElement(); |
| if (fo.isFolder()) { |
| loadChildren(fo); |
| assertNull("OpenIDE-Folder-Order attr should not be used on " + fo, fo.getAttribute("OpenIDE-Folder-Order")); |
| assertNull("OpenIDE-Folder-SortMode attr should not be used on " + fo, fo.getAttribute("OpenIDE-Folder-SortMode")); |
| String path = fo.getPath(); |
| Matcher m = editorFolder.matcher(path); |
| if (m.matches()) { |
| List<String> multiPath = new ArrayList<String>(3); |
| multiPath.add(path); |
| if (m.group(2).endsWith("+xml")) { |
| multiPath.add("Editors/" + m.group(1) + "/xml" + m.group(3)); |
| } |
| multiPath.add("Editors" + m.group(3)); |
| editorMultiFolders.add(multiPath); |
| } |
| } |
| } |
| assertNoErrors("No warnings relating to folder ordering; " + |
| "cf: http://deadlock.netbeans.org/job/nbms-and-javadoc/lastSuccessfulBuild/artifact/nbbuild/build/generated/layers.txt", h.errors()); |
| if (false) { |
| // temporarily disable multi-level checking of order, see discussion on dev@ mailing list on how |
| // the situation with some MIME types requiring positions and some not should be solved. |
| for (List<String> multiPath : editorMultiFolders) { |
| List<FileSystem> layers = new ArrayList<FileSystem>(3); |
| for (final String path : multiPath) { |
| FileObject folder = FileUtil.getConfigFile(path); |
| if (folder != null) { |
| layers.add(new MultiFileSystem(folder.getFileSystem()) { |
| protected @Override FileObject findResourceOn(FileSystem fs, String res) { |
| FileObject f = fs.findResource(path + '/' + res); |
| return Boolean.TRUE.equals(f.getAttribute("hidden")) ? null : f; |
| } |
| }); |
| } |
| } |
| loadChildren(new MultiFileSystem(layers.toArray(new FileSystem[layers.size()])).getRoot()); |
| appendFailure("\nNo warnings relating to folder ordering in " + multiPath + |
| "; cf: http://deadlock.netbeans.org/job/nbms-and-javadoc/lastSuccessfulBuild/artifact/nbbuild/build/generated/layers.txt", |
| h.errors()); |
| h.errors.clear(); |
| } |
| } |
| assertNoFailures(); |
| } |
| private static void loadChildren(FileObject folder) { |
| List<FileObject> kids = new ArrayList<FileObject>(); |
| for (DataObject kid : DataFolder.findFolder(folder).getChildren()) { |
| kids.add(kid.getPrimaryFile()); |
| } |
| FileUtil.getOrder(kids, true); |
| } |
| |
| private static Map<String,Object> getAttributes(FileObject fo, URL base) { |
| Map<String,Object> attrs = new TreeMap<String,Object>(); |
| Enumeration<String> en = fo.getAttributes(); |
| while (en.hasMoreElements()) { |
| String attrName = en.nextElement(); |
| if (isInstanceAttribute(attrName)) { |
| continue; |
| } |
| Object attr = fo.getAttribute(attrName); |
| if (attrName.equals(SFS_LB)) { |
| try { |
| String bundleName = (String) attr; |
| URL bundle = new URL(base, bundleName.replace('.', '/') + ".properties"); |
| Properties p = new Properties(); |
| InputStream is = bundle.openStream(); |
| try { |
| p.load(is); |
| } finally { |
| is.close(); |
| } |
| String path = fo.getPath(); |
| attr = p.get(path); |
| if (attr == null) { |
| attr = new MissingResourceException("No such bundle entry " + path + " in " + bundleName, bundleName, path); |
| } |
| } catch (Exception x) { |
| attr = x; |
| } |
| } |
| attrs.put(attrName, attr); |
| } |
| return attrs; |
| } |
| |
| private static final String[] SKIPPED = { |
| "Templates/GUIForms", |
| "Palette/Borders/javax-swing-border-", |
| "Palette/Layouts/javax-swing-BoxLayout", |
| "Templates/Beans/", |
| "PaletteUI/org-netbeans-modules-form-palette-CPComponent", |
| "Templates/Ant/CustomTask.java", |
| "Templates/Privileged/Main.shadow", |
| "Templates/Privileged/JFrame.shadow", |
| "Templates/Privileged/Class.shadow", |
| "Templates/Classes", |
| "Templates/JSP_Servlet", |
| "EnvironmentProviders/ProfileTypes/Execution/nb-j2ee-deployment.instance", |
| "Shortcuts/D-BACK_QUOTE.shadow", |
| "Windows2/Components/", // cannot be loaded with a headless toolkit, so we have to skip these for now |
| "Maven/actionTemplate.instance", // template |
| }; |
| private boolean skipFile(FileObject fo) { |
| String s = fo.getPath(); |
| |
| if (s.startsWith ("Templates/") && !s.startsWith ("Templates/Services")) { |
| if (s.endsWith (".shadow") || s.endsWith (".java")) { |
| return true; |
| } |
| } |
| |
| for (String skipped : SKIPPED) { |
| if (s.startsWith(skipped)) { |
| return true; |
| } |
| } |
| |
| String iof = (String) fo.getAttribute("instanceOf"); |
| if (iof != null) { |
| for (String clz : iof.split("[, ]+")) { |
| try { |
| Class<?> c = Lookup.getDefault().lookup(ClassLoader.class).loadClass(clz); |
| } catch (ClassNotFoundException x) { |
| // E.g. Services/Hidden/org-netbeans-lib-jsch-antlibrary.instance in ide cluster |
| // cannot be loaded (and would just be ignored) if running without java cluster |
| System.err.println("Warning: skipping " + fo.getPath() + " due to inaccessible interface " + clz); |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| public void testKeymapOverrides() throws Exception { // #170677 |
| List<String> warnings = new ArrayList<String>(); |
| FileObject keymapRoot = FileUtil.getConfigFile("Keymaps"); |
| if (keymapRoot == null) { |
| return; |
| } |
| FileObject[] keymaps = keymapRoot.getChildren(); |
| Map<String,Integer> definitionCountById = new HashMap<String,Integer>(); |
| assertTrue("Too many keymaps for too little bitfield", keymaps.length < 31); |
| int keymapFlag = 1; |
| for (FileObject keymap : keymaps) { |
| for (FileObject shortcut : keymap.getChildren()) { |
| DataObject d = DataObject.find(shortcut); |
| if (d instanceof DataShadow) { |
| String id = ((DataShadow) d).getOriginal().getPrimaryFile().getPath(); |
| Integer prior = definitionCountById.get(id); |
| // a single keymap may provide alternative shortcuts for a given action. Count just once |
| // per keymap. |
| definitionCountById.put(id, prior == null ? keymapFlag : prior | keymapFlag); |
| } else if (!d.getPrimaryFile().hasExt("shadow") && !d.getPrimaryFile().hasExt("removed")) { |
| warnings.add("Anomalous file " + d); |
| } // else #172453: BrokenDataShadow, OK |
| } |
| keymapFlag <<= 1; |
| } |
| int expected = (1 << keymaps.length) - 1; |
| for (FileObject shortcut : FileUtil.getConfigFile("Shortcuts").getChildren()) { |
| DataObject d = DataObject.find(shortcut); |
| if (d instanceof DataShadow) { |
| String id = ((DataShadow) d).getOriginal().getPrimaryFile().getPath(); |
| if (!org.openide.util.Utilities.isMac() && // Would fail on Mac due to applemenu module |
| Integer.valueOf(expected).equals(definitionCountById.get(id))) |
| { |
| String layers = Arrays.toString((URL[]) d.getPrimaryFile().getAttribute("layers")); |
| warnings.add(d.getPrimaryFile().getPath() + " " + layers + " useless since " + id + " is bound (somehow) in all keymaps"); |
| } |
| } else if (!d.getPrimaryFile().hasExt("shadow")) { |
| warnings.add("Anomalous file " + d); |
| } |
| } |
| // XXX consider also checking for bindings in Shortcuts/ which are overridden in all keymaps or at least NetBeans |
| // taking into consideration O- and D- virtual modifiers |
| // (this is likely to be more common, e.g. mysterious Shortcuts/D-A.shadow in uml.drawingarea) |
| // XXX check for shortcut conflict between Shortcuts and each keymap, e.g. Ctrl-R in Eclipse keymap |
| assertNoErrors("Some shortcuts were overridden by keymaps", warnings); |
| } |
| |
| /* XXX too many failures for now, some spurious; use regex, or look for unloc files/folders with loc siblings? |
| public void testLocalizedFolderNames() throws Exception { |
| List<String> warnings = new ArrayList<String>(); |
| for (String folder : new String[] { |
| "Actions", // many legit failures! |
| "OptionsDialog/Actions", // XXX #71280 |
| "Menu", |
| "Toolbars", |
| "org-netbeans-modules-java-hints/rules/hints", |
| "Editors/FontsColors", // XXX exclude .../Defaults |
| "Keymaps", |
| "FormDesignerPalette", // XXX match any *Palette? |
| "HTMLPalette", |
| "XHTMLPalette", |
| "JSPPalette", |
| "SVGXMLPalette", |
| "OptionsExport", |
| // "Projects/.../Customizer", |
| "QuickSearch", |
| "Templates", // XXX exclude Privileged, Recent, Services |
| }) { |
| FileObject root = FileUtil.getConfigFile(folder); |
| if (root == null) { |
| continue; |
| } |
| for (FileObject d : NbCollections.iterable(root.getFolders(true))) { |
| if (d.getAttribute("displayName") == null && d.getAttribute("SystemFileSystem.localizingBundle") == null) { |
| warnings.add("No displayName for " + d.getPath()); |
| } |
| } |
| } |
| assertNoErrors("Some folders need a localized display name", warnings); |
| } |
| */ |
| |
| public void testTemplates() throws Exception { // #167205 |
| List<String> warnings = new ArrayList<String>(); |
| for (FileObject f : NbCollections.iterable(FileUtil.getConfigFile("Templates").getData(true))) { |
| if (!Boolean.TRUE.equals(f.getAttribute("template"))) { |
| continue; // will not appear in Template Manager |
| } |
| if (f.getSize() > 0) { |
| continue; // Open in Editor will be enabled |
| } |
| if (f.getAttribute("instantiatingIterator") != null) { // TemplateWizard.CUSTOM_ITERATOR |
| continue; // probably not designed to be edited as text |
| } |
| if (f.getAttribute("templateWizardIterator") != null) { // TemplateWizard.EA_ITERATOR |
| continue; // same |
| } |
| String path = f.getPath(); |
| if (path.equals("Templates/Other/file") || |
| path.equals("Templates/Other/group.group") || |
| path.equals("Templates/Classes/Package")) { |
| |
| // If there're more files like this, consider adding an API |
| // to mark them as intentionally non-editable |
| continue; // intentionally empty and uneditable |
| } |
| warnings.add(path + " is empty but has no iterator and will therefore not be editable"); |
| } |
| assertNoErrors("Problems in templates", warnings); |
| } |
| |
| } |
