Attachment #65497 for bug #140680

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 140680
Collapse All | Expand All

Lines 59-64 import java.io.BufferedReader; Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/usages/RepositoryUpdater.java (-7 / +60 lines)
59	import java.io.BufferedReader;	59	import java.io.BufferedReader;
60	import java.io.File;	60	import java.io.File;
61	import java.io.FileInputStream;	61	import java.io.FileInputStream;
		62	import java.io.FileNotFoundException;
62	import java.io.FileOutputStream;	63	import java.io.FileOutputStream;
63	import java.io.IOException;	64	import java.io.IOException;
64	import java.io.InputStream;	65	import java.io.InputStream;
Lines 72-77 import java.net.URISyntaxException; Link Here
72	import java.net.URISyntaxException;	73	import java.net.URISyntaxException;
73	import java.net.URL;	74	import java.net.URL;
74	import java.nio.charset.Charset;	75	import java.nio.charset.Charset;
		76	import java.security.MessageDigest;
		77	import java.security.NoSuchAlgorithmException;
75	import java.util.ArrayList;	78	import java.util.ArrayList;
76	import java.util.Arrays;	79	import java.util.Arrays;
77	import java.util.Collection;	80	import java.util.Collection;
Lines 232-238 public class RepositoryUpdater implement Link Here
232	public Map<URL,List<URL>> getDependencies () {	235	public Map<URL,List<URL>> getDependencies () {
233	return new HashMap<URL,List<URL>> (this.deps);	236	return new HashMap<URL,List<URL>> (this.deps);
234	}	237	}
235		238
236	private synchronized void open () throws IllegalStateException {	239	private synchronized void open () throws IllegalStateException {
237	if (notInitialized) {	240	if (notInitialized) {
238	try {	241	try {
Lines 1750-1756 public class RepositoryUpdater implement Link Here
1750	final URL rootURL = it.previous();	1753	final URL rootURL = it.previous();
1751	it.remove();	1754	it.remove();
1752	if (!oldRoots.remove(rootURL) && !RepositoryUpdater.this.scannedRoots.contains(rootURL)) {	1755	if (!oldRoots.remove(rootURL) && !RepositoryUpdater.this.scannedRoots.contains(rootURL)) {
1753	long startT = System.currentTimeMillis();	1756	long startT = System.currentTimeMillis();
1754	updateFolder (rootURL,rootURL, true, false, handle);	1757	updateFolder (rootURL,rootURL, true, false, handle);
1755	long time = System.currentTimeMillis() - startT;	1758	long time = System.currentTimeMillis() - startT;
1756	if (PERF_TEST) {	1759	if (PERF_TEST) {
Lines 2164-2176 public class RepositoryUpdater implement Link Here
2164	}	2167	}
2165	final File classCache = Index.getClassFolder(rootFile);	2168	final File classCache = Index.getClassFolder(rootFile);
2166	final Map<URI, List<String>> misplacedSource2FQNs = new HashMap<URI, List<String>>();	2169	final Map<URI, List<String>> misplacedSource2FQNs = new HashMap<URI, List<String>>();
2167	Map <String,List<File>> resources = getAllClassFiles(classCache, FileObjects.getRelativePath(rootFile,folderFile),true);	2170	Map <String,List<File>> resources = Collections.<String, List<File>>emptyMap();
2168	final FileList children = new FileList(folderFile);	2171	final FileList children = new FileList(folderFile);
		2172	children.getJavaFiles();
2169	Set<File> compiledFiles = new HashSet<File>();	2173	Set<File> compiledFiles = new HashSet<File>();
2170	parseFiles(root, classCache, isInitialCompilation,	2174	if (children.digestChanged()) {
2171	children.getJavaFiles(), children.getVirtualJavaFiles(),	2175	resources = getAllClassFiles(classCache, FileObjects.getRelativePath(rootFile,folderFile),true);
2172	clean, handle, filter, resources, compiledFiles, null, misplacedSource2FQNs, false);	2176	parseFiles(root, classCache, isInitialCompilation,
2173		2177	children.getJavaFiles(), children.getVirtualJavaFiles(),
		2178	clean, handle, filter, resources, compiledFiles, null, misplacedSource2FQNs, false);
		2179	} else {
		2180	ClassIndexManager.getDefault().createUsagesQuery(root, true);
		2181	}
2174	if (!misplacedSource2FQNs.isEmpty()) {	2182	if (!misplacedSource2FQNs.isEmpty()) {
2175	if (LOGGER.isLoggable(Level.FINE)) {	2183	if (LOGGER.isLoggable(Level.FINE)) {
2176	LOGGER.log(Level.FINE, "misplaces classes detected");	2184	LOGGER.log(Level.FINE, "misplaces classes detected");
Lines 2697-2702 public class RepositoryUpdater implement Link Here
2697	private final List<File> javaFiles = new LinkedList<File>();	2705	private final List<File> javaFiles = new LinkedList<File>();
2698	private final List<File> virtualJavaFiles = new LinkedList<File>();	2706	private final List<File> virtualJavaFiles = new LinkedList<File>();
2699	private boolean initialized;	2707	private boolean initialized;
		2708	private boolean digestChanged = true;
2700		2709
2701	public FileList (final File root) {	2710	public FileList (final File root) {
2702	assert root != null;	2711	assert root != null;
Lines 2717-2724 public class RepositoryUpdater implement Link Here
2717	private synchronized void init () {	2726	private synchronized void init () {
2718	if (!initialized) {	2727	if (!initialized) {
2719	collectFiles (root, javaFiles, virtualJavaFiles);	2728	collectFiles (root, javaFiles, virtualJavaFiles);
		2729	computeDigest(root, javaFiles);
2720	initialized = true;	2730	initialized = true;
2721	}	2731	}
		2732	}
		2733
		2734	private boolean digestChanged() {
		2735	return digestChanged;
		2736	}
		2737
		2738	private void computeDigest(File root, final List<File> javaFiles) {
		2739	StringBuilder sb = new StringBuilder(200);
		2740	sb.append(SourceLevelQuery.getSourceLevel(FileUtil.toFileObject(root)));
		2741	for (File f : javaFiles) {
		2742	sb.append(f.getPath()).append(f.lastModified());
		2743	}
		2744	try {
		2745	MessageDigest md5 = MessageDigest.getInstance("MD5");
		2746	byte[] b = sb.toString().getBytes();
		2747	byte[] digest = md5.digest(b);
		2748	URL rootUrl = root.toURI().toURL();
		2749	Properties prop = loadProperties(rootUrl);
		2750	String data = prop.getProperty("digest");
		2751	if (data != null) {
		2752	String newDigest = printDigest(digest);
		2753	if (data.equals(newDigest) == true) {
		2754	digestChanged = false;
		2755	}
		2756	}
		2757	prop.put("digest", printDigest(digest));
		2758	storeProperties(rootUrl, prop);
		2759	} catch (IOException e) {
		2760	} catch (NoSuchAlgorithmException ex) {
		2761	Exceptions.printStackTrace(ex);
		2762	}
		2763	}
		2764
		2765	private String printDigest(byte[] digest) {
		2766	StringBuilder sb = new StringBuilder();
		2767	for (int i = 0; i < digest.length; i++) {
		2768	String hex = Integer.toHexString(0xFF & digest[i]);
		2769	if (hex.length() == 1) {
		2770	sb.append('0');
		2771	}
		2772	sb.append(hex);
		2773	}
		2774	return sb.toString();
2722	}	2775	}
2723		2776
2724	private static void collectFiles (final File root, final List<? super File> javaFiles,	2777	private static void collectFiles (final File root, final List<? super File> javaFiles,




package org.netbeans.modules.java.source.usages;

import java.io.File;
import java.io.FileDescriptor;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.net.URL;
import java.security.Permission;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import javax.swing.event.ChangeListener;
import junit.framework.Assert;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.classpath.GlobalPathRegistry;
import org.netbeans.api.java.source.JavaSource;

        super(testName);
    }
    
    @Override
    protected void setUp() throws Exception {
        SourceUtilsTestUtil.prepareTest(new String[0], new Object[0]);
        RepositoryUpdater.DELAY = 0;

        super.setUp();
    }
    
    @Override
    protected void tearDown() throws Exception {
        Logger.getLogger(RepositoryUpdater.class.getName()).removeHandler(handler);
        if (sourceCP != null) {

        assertTrue(TaskCache.getDefault().getErrors(fileA).toString(), TaskCache.getDefault().isInError(fileA, false));
        assertFalse(TaskCache.getDefault().getErrors(fileB).toString(), TaskCache.getDefault().isInError(fileB, false));
    }

    public void testFile() throws Exception {
        prepareTest("package pack; public class A { B.Inner x; }", "package pack; public class B {public static class Inner {}}");
        assertFalse(TaskCache.getDefault().getErrors(fileA).toString(), TaskCache.getDefault().isInError(fileA, false));
        assertFalse(TaskCache.getDefault().getErrors(fileB).toString(), TaskCache.getDefault().isInError(fileB, false));


        waitScanFinished();
        CountingSecurityManager.initialize(".class");

        File workDir = getWorkDir();
        File src     = new File(workDir, "src");
        ClassPath myRoot = ClassPathSupport.createClassPath(new FileObject[] {FileUtil.toFileObject(src)});
        RepositoryUpdater.getDefault();
        Set<ClassPath> kunda = GlobalPathRegistry.getDefault().getPaths(ClassPath.SOURCE);
        ClassPath cp = kunda.iterator().next();
        GlobalPathRegistry.getDefault().unregister(ClassPath.SOURCE, new ClassPath[] { cp });
        waitScanFinished();
        GlobalPathRegistry.getDefault().register(ClassPath.SOURCE, new ClassPath[] { cp });
        waitScanFinished();

        CountingSecurityManager.assertCounts("Expected", 0);

    }
    
    public void testFileUpdate2() throws Exception {
        prepareTest("package pack; public class A { B.Inner x; }", "package pack; public class B {public static class Inner {}}");

            "public static void tests() {}\n" +
            "}\n";
}

final class CountingSecurityManager extends SecurityManager {
    private static int cnt;
    private static StringWriter msgs;
    private static PrintWriter pw;
    private static String suffix;

    public static void initialize(String suffix) {
        if (System.getSecurityManager() instanceof CountingSecurityManager) {
            // ok
        } else {
            System.setSecurityManager(new CountingSecurityManager());
        }
        cnt = 0;
        msgs = new StringWriter();
        pw = new PrintWriter(msgs);
        CountingSecurityManager.suffix = suffix;
    }

    public static void assertCounts(String msg, int expectedCnt) {
        Assert.assertEquals(msg + "\n" + msgs, expectedCnt, cnt);
        cnt = 0;
        msgs = new StringWriter();
        pw = new PrintWriter(msgs);
    }

    @Override
    public void checkRead(String file) {
        if (file.endsWith(suffix)) {
            cnt++;
            pw.println("checkRead: " + file);
            new Exception().printStackTrace(pw);
        }
    }

    @Override
    public void checkRead(String file, Object context) {
        if (file.endsWith(suffix)) {
            cnt++;
            pw.println("checkRead2: " + file);
        }
    }

    @Override
    public void checkWrite(FileDescriptor fd) {
        cnt++;
        pw.println("Fd: " + fd);
    }

    @Override
    public void checkWrite(String file) {
        if (file.endsWith(suffix)) {
            cnt++;
            pw.println("checkWrite: " + file);
        }
    }

    @Override
    public void checkPermission(Permission perm) {
    }

    @Override
    public void checkPermission(Permission perm, Object context) {
    }
}

Return to bug 140680

Lines 42-57 package org.netbeans.modules.java.source Link Here

(-)a/java.source/test/unit/src/org/netbeans/modules/java/source/usages/RepositoryUpdaterTest.java (+97 lines)
42	package org.netbeans.modules.java.source.usages;	42	package org.netbeans.modules.java.source.usages;
43		43
44	import java.io.File;	44	import java.io.File;
		45	import java.io.FileDescriptor;
45	import java.io.IOException;	46	import java.io.IOException;
		47	import java.io.PrintWriter;
		48	import java.io.StringWriter;
46	import java.net.URL;	49	import java.net.URL;
		50	import java.security.Permission;
47	import java.util.Collection;	51	import java.util.Collection;
48	import java.util.List;	52	import java.util.List;
49	import java.util.Map;	53	import java.util.Map;
		54	import java.util.Set;
50	import java.util.logging.Handler;	55	import java.util.logging.Handler;
51	import java.util.logging.Level;	56	import java.util.logging.Level;
52	import java.util.logging.LogRecord;	57	import java.util.logging.LogRecord;
53	import java.util.logging.Logger;	58	import java.util.logging.Logger;
54	import javax.swing.event.ChangeListener;	59	import javax.swing.event.ChangeListener;
		60	import junit.framework.Assert;
55	import org.netbeans.api.java.classpath.ClassPath;	61	import org.netbeans.api.java.classpath.ClassPath;
56	import org.netbeans.api.java.classpath.GlobalPathRegistry;	62	import org.netbeans.api.java.classpath.GlobalPathRegistry;
57	import org.netbeans.api.java.source.JavaSource;	63	import org.netbeans.api.java.source.JavaSource;
Lines 86-91 public class RepositoryUpdaterTest exten Link Here
86	super(testName);	92	super(testName);
87	}	93	}
88		94
		95	@Override
89	protected void setUp() throws Exception {	96	protected void setUp() throws Exception {
90	SourceUtilsTestUtil.prepareTest(new String[0], new Object[0]);	97	SourceUtilsTestUtil.prepareTest(new String[0], new Object[0]);
91	RepositoryUpdater.DELAY = 0;	98	RepositoryUpdater.DELAY = 0;
Lines 106-111 public class RepositoryUpdaterTest exten Link Here
106	super.setUp();	113	super.setUp();
107	}	114	}
108		115
		116	@Override
109	protected void tearDown() throws Exception {	117	protected void tearDown() throws Exception {
110	Logger.getLogger(RepositoryUpdater.class.getName()).removeHandler(handler);	118	Logger.getLogger(RepositoryUpdater.class.getName()).removeHandler(handler);
111	if (sourceCP != null) {	119	if (sourceCP != null) {
Lines 304-309 public class RepositoryUpdaterTest exten Link Here
304	assertTrue(TaskCache.getDefault().getErrors(fileA).toString(), TaskCache.getDefault().isInError(fileA, false));	312	assertTrue(TaskCache.getDefault().getErrors(fileA).toString(), TaskCache.getDefault().isInError(fileA, false));
305	assertFalse(TaskCache.getDefault().getErrors(fileB).toString(), TaskCache.getDefault().isInError(fileB, false));	313	assertFalse(TaskCache.getDefault().getErrors(fileB).toString(), TaskCache.getDefault().isInError(fileB, false));
306	}	314	}
		315
		316	public void testFile() throws Exception {
		317	prepareTest("package pack; public class A { B.Inner x; }", "package pack; public class B {public static class Inner {}}");
		318	assertFalse(TaskCache.getDefault().getErrors(fileA).toString(), TaskCache.getDefault().isInError(fileA, false));
		319	assertFalse(TaskCache.getDefault().getErrors(fileB).toString(), TaskCache.getDefault().isInError(fileB, false));
		320
		321
		322	waitScanFinished();
		323	CountingSecurityManager.initialize(".class");
		324
		325	File workDir = getWorkDir();
		326	File src = new File(workDir, "src");
		327	ClassPath myRoot = ClassPathSupport.createClassPath(new FileObject[] {FileUtil.toFileObject(src)});
		328	RepositoryUpdater.getDefault();
		329	Set<ClassPath> kunda = GlobalPathRegistry.getDefault().getPaths(ClassPath.SOURCE);
		330	ClassPath cp = kunda.iterator().next();
		331	GlobalPathRegistry.getDefault().unregister(ClassPath.SOURCE, new ClassPath[] { cp });
		332	waitScanFinished();
		333	GlobalPathRegistry.getDefault().register(ClassPath.SOURCE, new ClassPath[] { cp });
		334	waitScanFinished();
		335
		336	CountingSecurityManager.assertCounts("Expected", 0);
		337
		338	}
307		339
308	public void testFileUpdate2() throws Exception {	340	public void testFileUpdate2() throws Exception {
309	prepareTest("package pack; public class A { B.Inner x; }", "package pack; public class B {public static class Inner {}}");	341	prepareTest("package pack; public class A { B.Inner x; }", "package pack; public class B {public static class Inner {}}");
Lines 449-451 public class RepositoryUpdaterTest exten Link Here
449	"public static void tests() {}\n" +	481	"public static void tests() {}\n" +
450	"}\n";	482	"}\n";
451	}	483	}
		484
		485	final class CountingSecurityManager extends SecurityManager {
		486	private static int cnt;
		487	private static StringWriter msgs;
		488	private static PrintWriter pw;
		489	private static String suffix;
		490
		491	public static void initialize(String suffix) {
		492	if (System.getSecurityManager() instanceof CountingSecurityManager) {
		493	// ok
		494	} else {
		495	System.setSecurityManager(new CountingSecurityManager());
		496	}
		497	cnt = 0;
		498	msgs = new StringWriter();
		499	pw = new PrintWriter(msgs);
		500	CountingSecurityManager.suffix = suffix;
		501	}
		502
		503	public static void assertCounts(String msg, int expectedCnt) {
		504	Assert.assertEquals(msg + "\n" + msgs, expectedCnt, cnt);
		505	cnt = 0;
		506	msgs = new StringWriter();
		507	pw = new PrintWriter(msgs);
		508	}
		509
		510	@Override
		511	public void checkRead(String file) {
		512	if (file.endsWith(suffix)) {
		513	cnt++;
		514	pw.println("checkRead: " + file);
		515	new Exception().printStackTrace(pw);
		516	}
		517	}
		518
		519	@Override
		520	public void checkRead(String file, Object context) {
		521	if (file.endsWith(suffix)) {
		522	cnt++;
		523	pw.println("checkRead2: " + file);
		524	}
		525	}
		526
		527	@Override
		528	public void checkWrite(FileDescriptor fd) {
		529	cnt++;
		530	pw.println("Fd: " + fd);
		531	}
		532
		533	@Override
		534	public void checkWrite(String file) {
		535	if (file.endsWith(suffix)) {
		536	cnt++;
		537	pw.println("checkWrite: " + file);
		538	}
		539	}
		540
		541	@Override
		542	public void checkPermission(Permission perm) {
		543	}
		544
		545	@Override
		546	public void checkPermission(Permission perm, Object context) {
		547	}
548	}