Attachment #63791 for bug #138772

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

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




                    <run-dependency>
                        <release-version>1</release-version>
                        <specification-version>1.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.bootstrap</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>1</release-version>
                        <specification-version>2.15</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.core.startup</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>1</release-version>
                        <specification-version>1.14</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>




import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.Module;
import org.netbeans.core.startup.Main;
import org.openide.modules.ModuleInfo;
import org.openide.util.Mutex;


    
    private Hacks() {}
    
    public static Module getModule (ModuleInfo info) {
        return Main.getModuleSystem().getManager().get(info.getCodeNameBase());
        try {
            Class clazz = Class.forName ("org.netbeans.core.startup.Main",
                    false,
                    Thread.currentThread().getContextClassLoader ());
            assert clazz != null : "Class org.netbeans.core.startup.Main found.";
            
            Method getModuleSystemMethod = clazz.getMethod ("getModuleSystem");
            assert getModuleSystemMethod != null : "Method getModuleSystem() found.";
            getModuleSystemMethod.setAccessible (true);
            
            Object moduleSystem = getModuleSystemMethod.invoke (null);
            assert moduleSystem != null : "Method getModuleSystem() returns ModuleSystem.";
            
            clazz = moduleSystem.getClass ();
            Method getManager = clazz.getMethod ("getManager");
            assert getManager != null : "Method getManager() found.";
            getManager.setAccessible (true);
            
            Object mgr = getManager.invoke (moduleSystem);
            assert mgr != null : "Method getManager() returns ModuleManager.";
            
            clazz = mgr.getClass ();
            Method getModule = clazz.getMethod ("get", String.class);
            assert getModule != null : "Method get(String codeName) found.";
            getModule.setAccessible (true);
            
            module = getModule.invoke (mgr, info.getCodeNameBase ());
            //assert module != null : "Method ModuleManager.get(" + info.getCodeNameBase () + ") returns Module.";
            
        } catch (Exception x) {
            err.log (Level.INFO, x.getMessage (), x);
        }
        
        err.log (Level.FINE, "ModuleInfo [" + info.getCodeName () + "/" + info.getSpecificationVersion() + " has module " + module);
        return module;
    }
    
    public static boolean isValid (ModuleInfo info) {

        
        err.log (Level.FINE, "Return new ModuleHistory (" + jar + "): " + moduleHistory);
        return moduleHistory;
    }
    
    public static String messageForProblem (ModuleInfo info, Object problem) {
        // NbProblemDisplayer.messageForProblem (Module m, Object problem)
        String res = null;
        try {
            Class clazz = Class.forName ("org.netbeans.core.startup.NbProblemDisplayer",
                    false,
                    Thread.currentThread ().getContextClassLoader ());
            assert clazz != null : "Class org.netbeans.core.startup.NbProblemDisplayer found.";
            
            Method messageForProblemM = clazz.getMethod ("messageForProblem", Class.forName ("org.netbeans.Module"), Object.class);
            messageForProblemM.setAccessible (true);
            assert getModule (info) != null;
            Object resO = messageForProblemM.invoke (null, getModule (info), problem);
            
            assert resO == null || resO instanceof String;
            
            res = resO == null ? null : (String) resO;
            
        } catch (Exception x) {
            err.log (Level.INFO, x.getMessage (), x);
        }
        
        err.log (Level.FINE, "messageForProblem (" + info + ", " + problem + ") returns " + res);
        return res;
    }
    
    public static ModuleManager getModuleManager () {




package org.netbeans.modules.modulemanager;

import java.awt.Component;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.logging.Logger;
import org.netbeans.*;
import java.util.*;
import javax.swing.SwingUtilities;
import org.openide.modules.SpecificationVersion;
import java.io.File;
import java.beans.*;
import org.openide.*;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.logging.Level;
import org.netbeans.Module;
import org.netbeans.core.startup.ModuleSystem;
import org.netbeans.core.startup.NbProblemDisplayer;
import org.openide.DialogDisplayer;
import org.openide.NotifyDescriptor;
import org.openide.modules.ModuleInfo;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;
import org.openide.util.RequestProcessor;
import org.openide.util.Task;
import org.openide.util.Union2;
import org.openide.util.WeakListeners;

/** Bean representing a module.
 * Mirrors its properties but provides safe access from the event thread.

            Iterator it = problems.iterator();
            int i = 0;
            while (it.hasNext()) {
                problemDescriptions[i++] = NbProblemDisplayer.messageForProblem(Hacks.getModule(moduleInfo), it.next(), true);
            }
        } else {
            problemDescriptions = null;




import java.util.Set;
import org.netbeans.Module;
import org.netbeans.core.startup.Main;
import org.netbeans.core.startup.NbProblemDisplayer;
import org.netbeans.junit.NbTestCase;
import org.openide.modules.Dependency;
import org.openide.modules.ModuleInfo;
import org.openide.util.Lookup;


            if (m.getJarFile () != null) {
                testCreateModuleHistory (m.getJarFile ().toString ());
            }
            testMessageForProblem (m);
            testGetEffectiveClasspath (m);
        }
    }

        }
    }

    private void testMessageForProblem (Module m) {
        try {
            Dependency dep = Dependency.create (Dependency.TYPE_REQUIRES, "org.netbeans.ufo").iterator ().next ();
            String result = Hacks.messageForProblem (m, dep);
            String excepted = NbProblemDisplayer.messageForProblem (m, dep);
            assertEquals ("Hacks.messageForProblem() returns as same as original NbProblemDisplayer.", excepted, result);
        } catch (Exception x) {
            fail (x.getMessage());
        }
    }

}

Return to bug 138772

Lines 38-43 Link Here

(-)a/modulemanager/src/org/netbeans/modules/modulemanager/Hacks.java (-63 / +4 lines)
38	import java.util.Set;	38	import java.util.Set;
39	import java.util.logging.Level;	39	import java.util.logging.Level;
40	import java.util.logging.Logger;	40	import java.util.logging.Logger;
		41	import org.netbeans.Module;
		42	import org.netbeans.core.startup.Main;
41	import org.openide.modules.ModuleInfo;	43	import org.openide.modules.ModuleInfo;
42	import org.openide.util.Mutex;	44	import org.openide.util.Mutex;
43		45
Lines 53-95 Link Here
53		55
54	private Hacks() {}	56	private Hacks() {}
55		57
56	public static Object getModule (ModuleInfo info) {	58	public static Module getModule (ModuleInfo info) {
57	Object module = null;	59	return Main.getModuleSystem().getManager().get(info.getCodeNameBase());
58	try {
59	Class clazz = Class.forName ("org.netbeans.core.startup.Main",
60	false,
61	Thread.currentThread().getContextClassLoader ());
62	assert clazz != null : "Class org.netbeans.core.startup.Main found.";
63
64	Method getModuleSystemMethod = clazz.getMethod ("getModuleSystem");
65	assert getModuleSystemMethod != null : "Method getModuleSystem() found.";
66	getModuleSystemMethod.setAccessible (true);
67
68	Object moduleSystem = getModuleSystemMethod.invoke (null);
69	assert moduleSystem != null : "Method getModuleSystem() returns ModuleSystem.";
70
71	clazz = moduleSystem.getClass ();
72	Method getManager = clazz.getMethod ("getManager");
73	assert getManager != null : "Method getManager() found.";
74	getManager.setAccessible (true);
75
76	Object mgr = getManager.invoke (moduleSystem);
77	assert mgr != null : "Method getManager() returns ModuleManager.";
78
79	clazz = mgr.getClass ();
80	Method getModule = clazz.getMethod ("get", String.class);
81	assert getModule != null : "Method get(String codeName) found.";
82	getModule.setAccessible (true);
83
84	module = getModule.invoke (mgr, info.getCodeNameBase ());
85	//assert module != null : "Method ModuleManager.get(" + info.getCodeNameBase () + ") returns Module.";
86
87	} catch (Exception x) {
88	err.log (Level.INFO, x.getMessage (), x);
89	}
90
91	err.log (Level.FINE, "ModuleInfo [" + info.getCodeName () + "/" + info.getSpecificationVersion() + " has module " + module);
92	return module;
93	}	60	}
94		61
95	public static boolean isValid (ModuleInfo info) {	62	public static boolean isValid (ModuleInfo info) {
Lines 196-227 Link Here
196		163
197	err.log (Level.FINE, "Return new ModuleHistory (" + jar + "): " + moduleHistory);	164	err.log (Level.FINE, "Return new ModuleHistory (" + jar + "): " + moduleHistory);
198	return moduleHistory;	165	return moduleHistory;
199	}
200
201	public static String messageForProblem (ModuleInfo info, Object problem) {
202	// NbProblemDisplayer.messageForProblem (Module m, Object problem)
203	String res = null;
204	try {
205	Class clazz = Class.forName ("org.netbeans.core.startup.NbProblemDisplayer",
206	false,
207	Thread.currentThread ().getContextClassLoader ());
208	assert clazz != null : "Class org.netbeans.core.startup.NbProblemDisplayer found.";
209
210	Method messageForProblemM = clazz.getMethod ("messageForProblem", Class.forName ("org.netbeans.Module"), Object.class);
211	messageForProblemM.setAccessible (true);
212	assert getModule (info) != null;
213	Object resO = messageForProblemM.invoke (null, getModule (info), problem);
214
215	assert resO == null \|\| resO instanceof String;
216
217	res = resO == null ? null : (String) resO;
218
219	} catch (Exception x) {
220	err.log (Level.INFO, x.getMessage (), x);
221	}
222
223	err.log (Level.FINE, "messageForProblem (" + info + ", " + problem + ") returns " + res);
224	return res;
225	}	166	}
226		167
227	public static ModuleManager getModuleManager () {	168	public static ModuleManager getModuleManager () {

Lines 42-59 Link Here

(-)a/modulemanager/src/org/netbeans/modules/modulemanager/ModuleBean.java (-6 / +27 lines)
42	package org.netbeans.modules.modulemanager;	42	package org.netbeans.modules.modulemanager;
43		43
44	import java.awt.Component;	44	import java.awt.Component;
		45	import java.beans.PropertyChangeEvent;
		46	import java.beans.PropertyChangeListener;
		47	import java.beans.PropertyChangeSupport;
45	import java.util.logging.Logger;	48	import java.util.logging.Logger;
46	import org.netbeans.*;
47	import java.util.*;
48	import javax.swing.SwingUtilities;	49	import javax.swing.SwingUtilities;
49	import org.openide.modules.SpecificationVersion;	50	import org.openide.modules.SpecificationVersion;
50	import java.io.File;	51	import java.io.File;
51	import java.beans.*;
52	import org.openide.*;
53	import java.io.IOException;	52	import java.io.IOException;
		53	import java.util.Arrays;
		54	import java.util.Collection;
		55	import java.util.Comparator;
		56	import java.util.HashMap;
		57	import java.util.HashSet;
		58	import java.util.Iterator;
		59	import java.util.LinkedList;
		60	import java.util.List;
		61	import java.util.Map;
		62	import java.util.Set;
		63	import java.util.SortedSet;
		64	import java.util.TreeSet;
54	import java.util.logging.Level;	65	import java.util.logging.Level;
		66	import org.netbeans.Module;
		67	import org.netbeans.core.startup.ModuleSystem;
		68	import org.netbeans.core.startup.NbProblemDisplayer;
		69	import org.openide.DialogDisplayer;
		70	import org.openide.NotifyDescriptor;
55	import org.openide.modules.ModuleInfo;	71	import org.openide.modules.ModuleInfo;
56	import org.openide.util.*;	72	import org.openide.util.Exceptions;
		73	import org.openide.util.NbBundle;
		74	import org.openide.util.RequestProcessor;
		75	import org.openide.util.Task;
		76	import org.openide.util.Union2;
		77	import org.openide.util.WeakListeners;
57		78
58	/** Bean representing a module.	79	/** Bean representing a module.
59	* Mirrors its properties but provides safe access from the event thread.	80	* Mirrors its properties but provides safe access from the event thread.
Lines 125-131 Link Here
125	Iterator it = problems.iterator();	146	Iterator it = problems.iterator();
126	int i = 0;	147	int i = 0;
127	while (it.hasNext()) {	148	while (it.hasNext()) {
128	problemDescriptions[i++] = Hacks.messageForProblem(moduleInfo, it.next());	149	problemDescriptions[i++] = NbProblemDisplayer.messageForProblem(Hacks.getModule(moduleInfo), it.next(), true);
129	}	150	}
130	} else {	151	} else {
131	problemDescriptions = null;	152	problemDescriptions = null;

Lines 34-42 Link Here

(-)a/modulemanager/test/unit/src/org/netbeans/modules/modulemanager/HacksTest.java (-14 lines)
34	import java.util.Set;	34	import java.util.Set;
35	import org.netbeans.Module;	35	import org.netbeans.Module;
36	import org.netbeans.core.startup.Main;	36	import org.netbeans.core.startup.Main;
37	import org.netbeans.core.startup.NbProblemDisplayer;
38	import org.netbeans.junit.NbTestCase;	37	import org.netbeans.junit.NbTestCase;
39	import org.openide.modules.Dependency;
40	import org.openide.modules.ModuleInfo;	38	import org.openide.modules.ModuleInfo;
41	import org.openide.util.Lookup;	39	import org.openide.util.Lookup;
42		40
Lines 79-85 Link Here
79	if (m.getJarFile () != null) {	77	if (m.getJarFile () != null) {
80	testCreateModuleHistory (m.getJarFile ().toString ());	78	testCreateModuleHistory (m.getJarFile ().toString ());
81	}	79	}
82	testMessageForProblem (m);
83	testGetEffectiveClasspath (m);	80	testGetEffectiveClasspath (m);
84	}	81	}
85	}	82	}
Lines 256-270 Link Here
256	}	253	}
257	}	254	}
258		255
259	private void testMessageForProblem (Module m) {
260	try {
261	Dependency dep = Dependency.create (Dependency.TYPE_REQUIRES, "org.netbeans.ufo").iterator ().next ();
262	String result = Hacks.messageForProblem (m, dep);
263	String excepted = NbProblemDisplayer.messageForProblem (m, dep);
264	assertEquals ("Hacks.messageForProblem() returns as same as original NbProblemDisplayer.", excepted, result);
265	} catch (Exception x) {
266	fail (x.getMessage());
267	}
268	}
269
270	}	256	}

Lines 53-58 Link Here

(-)a/modulemanager/nbproject/project.xml (+18 lines)
53	<run-dependency>	53	<run-dependency>
54	<release-version>1</release-version>	54	<release-version>1</release-version>
55	<specification-version>1.0</specification-version>	55	<specification-version>1.0</specification-version>
		56	</run-dependency>
		57	</dependency>
		58	<dependency>
		59	<code-name-base>org.netbeans.bootstrap</code-name-base>
		60	<build-prerequisite/>
		61	<compile-dependency/>
		62	<run-dependency>
		63	<release-version>1</release-version>
		64	<specification-version>2.15</specification-version>
		65	</run-dependency>
		66	</dependency>
		67	<dependency>
		68	<code-name-base>org.netbeans.core.startup</code-name-base>
		69	<build-prerequisite/>
		70	<compile-dependency/>
		71	<run-dependency>
		72	<release-version>1</release-version>
		73	<specification-version>1.14</specification-version>
56	</run-dependency>	74	</run-dependency>
57	</dependency>	75	</dependency>
58	<dependency>	76	<dependency>