| /******************************************************************************* |
| * Copyright (c) 2006, 2014 Wind River Systems, Inc. and others. |
| * |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Markus Schorn - initial API and implementation |
| * Sergey Prigogin (Google) |
| *******************************************************************************/ |
| package org.eclipse.cdt.internal.index.tests; |
| |
| import static org.eclipse.cdt.core.testplugin.util.TestSourceReader.createFile; |
| |
| import java.io.ByteArrayInputStream; |
| import java.util.HashSet; |
| import java.util.Set; |
| import java.util.regex.Pattern; |
| |
| import org.eclipse.cdt.core.CCorePlugin; |
| import org.eclipse.cdt.core.dom.ILinkage; |
| import org.eclipse.cdt.core.dom.IPDOMManager; |
| import org.eclipse.cdt.core.dom.ast.IBinding; |
| import org.eclipse.cdt.core.dom.ast.IVariable; |
| import org.eclipse.cdt.core.index.IIndex; |
| import org.eclipse.cdt.core.index.IIndexBinding; |
| import org.eclipse.cdt.core.index.IIndexFile; |
| import org.eclipse.cdt.core.index.IIndexFileLocation; |
| import org.eclipse.cdt.core.index.IIndexInclude; |
| import org.eclipse.cdt.core.index.IndexFilter; |
| import org.eclipse.cdt.core.index.IndexLocationFactory; |
| import org.eclipse.cdt.core.model.CoreModel; |
| import org.eclipse.cdt.core.model.ICProject; |
| import org.eclipse.cdt.core.model.IPathEntry; |
| import org.eclipse.cdt.core.testplugin.CProjectHelper; |
| import org.eclipse.cdt.core.testplugin.TestScannerProvider; |
| import org.eclipse.cdt.core.testplugin.util.TestSourceReader; |
| import org.eclipse.cdt.internal.core.pdom.indexer.IndexerPreferences; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IWorkspaceRunnable; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.Path; |
| import org.junit.Assert; |
| |
| import junit.framework.TestSuite; |
| |
| public class IndexIncludeTest extends IndexTestBase { |
| |
| public static TestSuite suite() { |
| TestSuite suite = suite(IndexIncludeTest.class, "_"); |
| suite.addTest(new IndexIncludeTest("deleteProject")); |
| return suite; |
| } |
| |
| private ICProject fProject; |
| private IIndex fIndex; |
| |
| public IndexIncludeTest(String name) { |
| super(name); |
| } |
| |
| @Override |
| public void setUp() throws Exception { |
| super.setUp(); |
| if (fProject == null) { |
| fProject = createProject(true, "resources/indexTests/includes"); |
| IPathEntry[] entries = new IPathEntry[] { |
| CoreModel.newIncludeEntry(fProject.getPath(), null, fProject.getResource().getLocation()) }; |
| fProject.setRawPathEntries(entries, npm()); |
| IndexerPreferences.set(fProject.getProject(), IndexerPreferences.KEY_INDEX_UNUSED_HEADERS_WITH_DEFAULT_LANG, |
| "false"); |
| } |
| fIndex = CCorePlugin.getIndexManager().getIndex(fProject); |
| } |
| |
| @Override |
| public void tearDown() throws Exception { |
| super.tearDown(); |
| } |
| |
| public void deleteProject() { |
| if (fProject != null) { |
| CProjectHelper.delete(fProject); |
| } |
| } |
| |
| public void testFastIndexer() throws Exception { |
| CCorePlugin.getIndexManager().setIndexerId(fProject, IPDOMManager.ID_FAST_INDEXER); |
| IndexerPreferences.set(fProject.getProject(), IndexerPreferences.KEY_INDEX_UNUSED_HEADERS_WITH_DEFAULT_LANG, |
| "false"); |
| waitForIndexer(); |
| checkHeader(false); |
| |
| IndexerPreferences.set(fProject.getProject(), IndexerPreferences.KEY_INDEX_UNUSED_HEADERS_WITH_DEFAULT_LANG, |
| "true"); |
| waitForIndexer(); |
| checkHeader(true); |
| |
| checkContext(); |
| } |
| |
| private void waitForIndexer() throws InterruptedException { |
| waitForIndexer(fProject); |
| } |
| |
| private void checkHeader(boolean all) throws Exception { |
| fIndex.acquireReadLock(); |
| try { |
| IIndexBinding[] result = fIndex.findBindings(Pattern.compile(".*included"), true, IndexFilter.ALL, npm()); |
| assertEquals(all ? 2 : 1, result.length); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| private void checkContext() throws Exception { |
| final long timestamp = System.currentTimeMillis(); |
| final IFile file = (IFile) fProject.getProject().findMember(new Path("included.h")); |
| assertNotNull("Can't find included.h", file); |
| waitForIndexer(); |
| |
| ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() { |
| @Override |
| public void run(IProgressMonitor monitor) throws CoreException { |
| file.setContents(new ByteArrayInputStream("int included; int CONTEXT;\n".getBytes()), false, false, |
| npm()); |
| file.setLocalTimeStamp(timestamp + 1000); |
| } |
| }, npm()); |
| assertTrue("Timestamp was not increased", file.getLocalTimeStamp() >= timestamp); |
| waitUntilFileIsIndexed(fIndex, file); |
| fIndex.acquireReadLock(); |
| try { |
| IIndexFile ifile = getIndexFile(file); |
| assertTrue("Timestamp not ok", ifile.getTimestamp() >= timestamp); |
| |
| IIndexBinding[] result = fIndex.findBindings(Pattern.compile("testInclude_cpp"), true, IndexFilter.ALL, |
| npm()); |
| assertEquals(1, result.length); |
| |
| result = fIndex.findBindings("testInclude_cpp".toCharArray(), IndexFilter.ALL, npm()); |
| assertEquals(1, result.length); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| private IIndexFile getIndexFile(IFile file) throws CoreException { |
| IIndexFile[] files = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, IndexLocationFactory.getWorkspaceIFL(file)); |
| assertTrue("Can't find " + file.getLocation(), files.length > 0); |
| assertEquals("Found " + files.length + " files for " + file.getLocation() + " instead of one", 1, files.length); |
| return files[0]; |
| } |
| |
| // {source20061107} |
| // #include "user20061107.h" |
| // #include <system20061107.h> |
| public void testIncludeProperties() throws Exception { |
| waitForIndexer(); |
| TestScannerProvider.sIncludes = new String[] { fProject.getProject().getLocation().toOSString() }; |
| String content = readTaggedComment("source20061107"); |
| TestSourceReader.createFile(fProject.getProject(), "user20061107.h", ""); |
| TestSourceReader.createFile(fProject.getProject(), "system20061107.h", ""); |
| IFile file = TestSourceReader.createFile(fProject.getProject(), "source20061107.cpp", content); |
| waitUntilFileIsIndexed(fIndex, file); |
| |
| fIndex.acquireReadLock(); |
| try { |
| IIndexFile ifile = getIndexFile(file); |
| IIndexInclude[] includes = ifile.getIncludes(); |
| assertEquals(2, includes.length); |
| |
| checkInclude(includes[0], content, "user20061107.h", false); |
| checkInclude(includes[1], content, "system20061107.h", true); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| public void testIncludeProperties_2() throws Exception { |
| TestScannerProvider.sIncludes = new String[] { fProject.getProject().getLocation().toOSString() }; |
| TestSourceReader.createFile(fProject.getProject(), "header20061107.h", ""); |
| String content = "// comment \n#include \"header20061107.h\"\n"; |
| IFile file = TestSourceReader.createFile(fProject.getProject(), "intermed20061107.h", content); |
| TestSourceReader.createFile(fProject.getProject(), "source20061107.cpp", "#include \"intermed20061107.h\"\n"); |
| CCorePlugin.getIndexManager().reindex(fProject); |
| waitForIndexer(); |
| |
| fIndex.acquireReadLock(); |
| try { |
| IIndexFile ifile = getIndexFile(file); |
| IIndexInclude[] includes = ifile.getIncludes(); |
| assertEquals(1, includes.length); |
| |
| checkInclude(includes[0], content, "header20061107.h", false); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| public void testInactiveInclude() throws Exception { |
| TestScannerProvider.sIncludes = new String[] { fProject.getProject().getLocation().toOSString() }; |
| String content = "#if 0\n#include \"inactive20070213.h\"\n#endif\n"; |
| IFile file = TestSourceReader.createFile(fProject.getProject(), "source20070213.cpp", content); |
| CCorePlugin.getIndexManager().reindex(fProject); |
| waitForIndexer(); |
| |
| fIndex.acquireReadLock(); |
| try { |
| IIndexFile ifile = getIndexFile(file); |
| IIndexInclude[] includes = ifile.getIncludes(); |
| assertEquals(1, includes.length); |
| |
| assertFalse(includes[0].isActive()); |
| checkInclude(includes[0], content, "inactive20070213.h", false); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| public void testUnresolvedInclude() throws Exception { |
| TestScannerProvider.sIncludes = new String[] { fProject.getProject().getLocation().toOSString() }; |
| String content = "#include \"unresolved20070213.h\"\n"; |
| IFile file = TestSourceReader.createFile(fProject.getProject(), "source20070214.cpp", content); |
| CCorePlugin.getIndexManager().reindex(fProject); |
| waitForIndexer(); |
| |
| fIndex.acquireReadLock(); |
| try { |
| IIndexFile ifile = getIndexFile(file); |
| IIndexInclude[] includes = ifile.getIncludes(); |
| assertEquals(1, includes.length); |
| |
| assertTrue(includes[0].isActive()); |
| assertFalse(includes[0].isResolved()); |
| checkInclude(includes[0], content, "unresolved20070213.h", false); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| private void checkInclude(IIndexInclude include, String content, String includeName, boolean isSystem) |
| throws CoreException { |
| int offset = content.indexOf(includeName); |
| assertEquals(offset, include.getNameOffset()); |
| assertEquals(includeName.length(), include.getNameLength()); |
| assertEquals(isSystem, include.isSystemInclude()); |
| } |
| |
| public void testUpdateOfIncluded() throws Exception { |
| String content1 = "int CONTEXT_20070404(x);\n"; |
| String content2 = "int CONTEXT_20070404(y);\n"; |
| String content3 = "#define CONTEXT_20070404(x) ctx_20070404##x\n" + "#include \"included_20070404.h\"\n" |
| + "int source_20070404;\n"; |
| TestSourceReader.createFile(fProject.getProject(), "included_20070404.h", content1); |
| TestSourceReader.createFile(fProject.getProject(), "notIncluded_20070404.h", "int notIncluded_20070404\n;"); |
| TestSourceReader.createFile(fProject.getProject(), "includer_20070404.cpp", content3); |
| IndexerPreferences.set(fProject.getProject(), IndexerPreferences.KEY_INDEX_UNUSED_HEADERS_WITH_DEFAULT_LANG, |
| "false"); |
| CCorePlugin.getIndexManager().reindex(fProject); |
| waitForIndexer(); |
| |
| fIndex.acquireReadLock(); |
| try { |
| assertEquals(0, fIndex.findBindings("notIncluded_20070404".toCharArray(), IndexFilter.ALL, npm()).length); |
| assertEquals(1, fIndex.findBindings("source_20070404".toCharArray(), IndexFilter.ALL, npm()).length); |
| IBinding[] bindings = fIndex.findBindings("ctx_20070404x".toCharArray(), IndexFilter.ALL, npm()); |
| assertEquals(1, bindings.length); |
| assertTrue(bindings[0] instanceof IVariable); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| |
| Thread.sleep(1000); |
| // now change the header and see whether it gets parsed |
| TestSourceReader.createFile(fProject.getProject(), "included_20070404.h", content2); |
| TestSourceReader.createFile(fProject.getProject(), "notIncluded_20070404.h", "int notIncluded_20070404\n;"); |
| Thread.sleep(1000); |
| waitForIndexer(); |
| |
| fIndex.acquireReadLock(); |
| try { |
| assertEquals(0, fIndex.findBindings("notIncluded_20070404".toCharArray(), IndexFilter.ALL, npm()).length); |
| IBinding[] bindings = fIndex.findBindings("ctx_20070404y".toCharArray(), IndexFilter.ALL, npm()); |
| assertEquals(1, bindings.length); |
| assertTrue(bindings[0] instanceof IVariable); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| // #define SOME_MACRO1 ok_1_220358 |
| // #define SOME_MACRO2 ok_2_220358 |
| |
| // int SOME_MACRO1; |
| |
| // int SOME_MACRO2; |
| |
| // #include "header1.h" |
| // #include "header2.h" |
| public void testParsingInContext_bug220358() throws Exception { |
| CharSequence[] sources = getContentsForTest(4); |
| IFile h1 = TestSourceReader.createFile(fProject.getProject(), "header1.h", sources[0].toString()); |
| IFile h2 = TestSourceReader.createFile(fProject.getProject(), "header2.h", sources[1].toString()); |
| IFile s1 = TestSourceReader.createFile(fProject.getProject(), "s1.cpp", sources[3].toString()); |
| // make sure it is parsed in context |
| waitForIndexer(); |
| CCorePlugin.getIndexManager().reindex(fProject); |
| waitForIndexer(); |
| |
| fIndex.acquireReadLock(); |
| try { |
| IIndexBinding[] binding = fIndex.findBindings("ok_1_220358".toCharArray(), IndexFilter.ALL_DECLARED, npm()); |
| assertEquals(1, binding.length); |
| assertTrue(binding[0] instanceof IVariable); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| |
| // change header2: |
| h2 = TestSourceReader.createFile(fProject.getProject(), "header2.h", sources[2].toString()); |
| TestSourceReader.waitUntilFileIsIndexed(fIndex, h2, INDEXER_TIMEOUT_MILLISEC); |
| fIndex.acquireReadLock(); |
| try { |
| IIndexBinding[] binding = fIndex.findBindings("ok_2_220358".toCharArray(), IndexFilter.ALL_DECLARED, npm()); |
| assertEquals(1, binding.length); |
| assertTrue(binding[0] instanceof IVariable); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| // #include "resolved20070426.h" |
| public void testFixedContext() throws Exception { |
| TestScannerProvider.sIncludes = new String[] { fProject.getProject().getLocation().toOSString() }; |
| String source = getContentsForTest(1)[0].toString(); |
| IFile header = TestSourceReader.createFile(fProject.getProject(), "resolved20070426.h", ""); |
| IFile s1 = TestSourceReader.createFile(fProject.getProject(), "s1.cpp", source); |
| // make sure it is parsed in context |
| waitForIndexer(); |
| CCorePlugin.getIndexManager().reindex(fProject); |
| waitForIndexer(); |
| |
| IFile s2 = TestSourceReader.createFile(fProject.getProject(), "s2.cpp", source); |
| TestSourceReader.waitUntilFileIsIndexed(fIndex, s2, INDEXER_TIMEOUT_MILLISEC); |
| |
| fIndex.acquireReadLock(); |
| try { |
| IIndexFile ifile = getIndexFile(header); |
| IIndexInclude[] includes = fIndex.findIncludedBy(ifile); |
| assertEquals(2, includes.length); |
| |
| IIndexInclude context = ifile.getParsedInContext(); |
| assertNotNull(context); |
| assertEquals(s1.getFullPath().toString(), context.getIncludedByLocation().getFullPath()); |
| |
| assertEquals(s1.getFullPath().toString(), includes[0].getIncludedByLocation().getFullPath()); |
| assertEquals(s2.getFullPath().toString(), includes[1].getIncludedByLocation().getFullPath()); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| |
| s1 = TestSourceReader.createFile(fProject.getProject(), "s1.cpp", source + "\nint a20070426;"); |
| TestSourceReader.waitUntilFileIsIndexed(fIndex, s1, INDEXER_TIMEOUT_MILLISEC); |
| fIndex.acquireReadLock(); |
| try { |
| assertEquals(1, fIndex.findBindings("a20070426".toCharArray(), IndexFilter.ALL_DECLARED, npm()).length); |
| IIndexFile ifile = getIndexFile(header); |
| IIndexInclude[] includes = fIndex.findIncludedBy(ifile); |
| assertEquals(2, includes.length); |
| assertEquals(s1.getFullPath().toString(), includes[0].getIncludedByLocation().getFullPath()); |
| assertEquals(s2.getFullPath().toString(), includes[1].getIncludedByLocation().getFullPath()); |
| IIndexInclude context = ifile.getParsedInContext(); |
| assertNotNull(context); |
| assertEquals(s1.getFullPath().toString(), context.getIncludedByLocation().getFullPath()); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| |
| s2 = TestSourceReader.createFile(fProject.getProject(), "s2.cpp", source + "\nint b20070426;"); |
| TestSourceReader.waitUntilFileIsIndexed(fIndex, s1, INDEXER_TIMEOUT_MILLISEC); |
| fIndex.acquireReadLock(); |
| try { |
| assertEquals(1, fIndex.findBindings("b20070426".toCharArray(), IndexFilter.ALL_DECLARED, npm()).length); |
| IIndexFile ifile = getIndexFile(header); |
| IIndexInclude[] includes = fIndex.findIncludedBy(ifile); |
| assertEquals(2, includes.length); |
| assertEquals(s1.getFullPath().toString(), includes[0].getIncludedByLocation().getFullPath()); |
| assertEquals(s2.getFullPath().toString(), includes[1].getIncludedByLocation().getFullPath()); |
| IIndexInclude context = ifile.getParsedInContext(); |
| assertNotNull(context); |
| assertEquals(s1.getFullPath().toString(), context.getIncludedByLocation().getFullPath()); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| // #include "resolved20070427.h" |
| // #include "unesolved20070427.h" |
| // #if 0 |
| // #include "inactive20070427.h" |
| // #endif |
| |
| // #include <unesolved20070427.h> |
| // #if 0 |
| // #include <inactive20070427.h> |
| // #endif |
| |
| // #include <resolved20070427.h> |
| // #if 0 |
| // #include <inactive20070427.h> |
| // #endif |
| |
| // #include "resolved20070427.h" |
| // #include "unesolved20070427.h" |
| public void testUpdateIncludes() throws Exception { |
| waitForIndexer(); |
| TestScannerProvider.sIncludes = new String[] { fProject.getProject().getLocation().toOSString() }; |
| CharSequence[] source = getContentsForTest(4); |
| IFile header = TestSourceReader.createFile(fProject.getProject(), "resolved20070427.h", ""); |
| IFile s1 = TestSourceReader.createFile(fProject.getProject(), "s20070427.cpp", |
| source[0].toString() + "\nint a20070427;"); |
| TestSourceReader.waitUntilFileIsIndexed(fIndex, s1, INDEXER_TIMEOUT_MILLISEC); |
| standardCheckUpdateIncludes(header, s1, "a20070427"); |
| |
| s1 = TestSourceReader.createFile(fProject.getProject(), "s20070427.cpp", |
| source[0].toString() + "\nint b20070427;"); |
| TestSourceReader.waitUntilFileIsIndexed(fIndex, s1, INDEXER_TIMEOUT_MILLISEC); |
| standardCheckUpdateIncludes(header, s1, "b20070427"); |
| |
| s1 = TestSourceReader.createFile(fProject.getProject(), "s20070427.cpp", |
| source[1].toString() + "\nint c20070427;"); |
| TestSourceReader.waitUntilFileIsIndexed(fIndex, s1, INDEXER_TIMEOUT_MILLISEC); |
| checkUpdateIncludes1(header, s1, "c20070427"); |
| |
| s1 = TestSourceReader.createFile(fProject.getProject(), "s20070427.cpp", |
| source[0].toString() + "\nint d20070427;"); |
| TestSourceReader.waitUntilFileIsIndexed(fIndex, s1, INDEXER_TIMEOUT_MILLISEC); |
| standardCheckUpdateIncludes(header, s1, "d20070427"); |
| |
| s1 = TestSourceReader.createFile(fProject.getProject(), "s20070427.cpp", |
| source[2].toString() + "\nint e20070427;"); |
| TestSourceReader.waitUntilFileIsIndexed(fIndex, s1, INDEXER_TIMEOUT_MILLISEC); |
| checkUpdateIncludes2(header, s1, "e20070427"); |
| |
| s1 = TestSourceReader.createFile(fProject.getProject(), "s20070427.cpp", |
| source[0].toString() + "\nint f20070427;"); |
| TestSourceReader.waitUntilFileIsIndexed(fIndex, s1, INDEXER_TIMEOUT_MILLISEC); |
| standardCheckUpdateIncludes(header, s1, "f20070427"); |
| |
| s1 = TestSourceReader.createFile(fProject.getProject(), "s20070427.cpp", |
| source[3].toString() + "\nint g20070427;"); |
| TestSourceReader.waitUntilFileIsIndexed(fIndex, s1, INDEXER_TIMEOUT_MILLISEC); |
| checkUpdateIncludes3(header, s1, "g20070427"); |
| |
| s1 = TestSourceReader.createFile(fProject.getProject(), "s20070427.cpp", |
| source[0].toString() + "\nint h20070427;"); |
| TestSourceReader.waitUntilFileIsIndexed(fIndex, s1, INDEXER_TIMEOUT_MILLISEC); |
| standardCheckUpdateIncludes(header, s1, "h20070427"); |
| } |
| |
| // #ifdef A |
| // static const int a = 0; |
| // #endif |
| // #ifdef B |
| // static const int b = 0; |
| // #endif |
| // #ifdef C |
| // static const int c = 0; |
| // #endif |
| |
| // #define A |
| // #include "h1.h" |
| // #undef A |
| // #define B |
| // #include "h1.h" |
| // #undef B |
| |
| // #define C |
| // #include "h1.h" |
| |
| // #include "h2.h" |
| public void testMultiVariantHeaderUpdate() throws Exception { |
| waitForIndexer(); |
| TestScannerProvider.sIncludes = new String[] { fProject.getProject().getLocation().toOSString() }; |
| StringBuilder[] contents = getContentsForTest(4); |
| final StringBuilder h1Contents = contents[0]; |
| final IFile h1 = TestSourceReader.createFile(fProject.getProject(), "h1.h", h1Contents.toString()); |
| IFile h2 = TestSourceReader.createFile(fProject.getProject(), "h2.h", contents[1].toString()); |
| IFile s1 = TestSourceReader.createFile(fProject.getProject(), "s1.cpp", contents[2].toString()); |
| IFile s2 = TestSourceReader.createFile(fProject.getProject(), "s2.cpp", contents[3].toString()); |
| TestSourceReader.waitUntilFileIsIndexed(fIndex, s1, INDEXER_TIMEOUT_MILLISEC); |
| TestSourceReader.waitUntilFileIsIndexed(fIndex, s2, INDEXER_TIMEOUT_MILLISEC); |
| |
| fIndex.acquireReadLock(); |
| try { |
| IIndexFile[] indexFiles = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, |
| IndexLocationFactory.getWorkspaceIFL(h1)); |
| assertEquals(3, indexFiles.length); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| |
| final long timestamp = System.currentTimeMillis(); |
| while (true) { |
| int pos = h1Contents.indexOf("int"); |
| if (pos < 0) |
| break; |
| h1Contents.replace(pos, pos + "int".length(), "float"); |
| } |
| ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() { |
| @Override |
| public void run(IProgressMonitor monitor) throws CoreException { |
| h1.setContents(new ByteArrayInputStream(h1Contents.toString().getBytes()), false, false, npm()); |
| h1.setLocalTimeStamp(timestamp + 1000); |
| } |
| }, npm()); |
| waitForIndexer(); |
| |
| fIndex.acquireReadLock(); |
| try { |
| IIndexFile[] indexFiles = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, |
| IndexLocationFactory.getWorkspaceIFL(h1)); |
| assertEquals(3, indexFiles.length); |
| for (IIndexFile indexFile : indexFiles) { |
| assertTrue("Timestamp not ok", indexFile.getTimestamp() >= timestamp); |
| } |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| // #ifdef A |
| // static const int a = 0; |
| // #endif |
| // #ifdef B |
| // static const int b = 0; |
| // #endif |
| // #ifdef C |
| // static const int c = 0; |
| // #endif |
| |
| // #define A |
| // #include "h1.h" |
| // #undef A |
| // #define B |
| // #include "h1.h" |
| // #undef B |
| |
| // #define C |
| // #include "h1.h" |
| |
| // #include "h2.h" |
| |
| // #ifndef H1_H_ |
| // #define H1_H_ |
| // #ifdef A |
| // static const int a = 0; |
| // #endif |
| // #ifdef B |
| // static const int b = 0; |
| // #endif |
| // #ifdef C |
| // static const int c = 0; |
| // #endif |
| // #endif // H1_H_ |
| public void testPragmaOnceChange() throws Exception { |
| waitForIndexer(); |
| TestScannerProvider.sIncludes = new String[] { fProject.getProject().getLocation().toOSString() }; |
| CharSequence[] contents = getContentsForTest(5); |
| final CharSequence h1Contents = contents[0]; |
| final IFile h1 = TestSourceReader.createFile(fProject.getProject(), "h1.h", h1Contents.toString()); |
| IFile h2 = TestSourceReader.createFile(fProject.getProject(), "h2.h", contents[1].toString()); |
| IFile s1 = TestSourceReader.createFile(fProject.getProject(), "s1.cpp", contents[2].toString()); |
| waitUntilFileIsIndexed(fIndex, s1); |
| IFile s2 = TestSourceReader.createFile(fProject.getProject(), "s2.cpp", contents[3].toString()); |
| waitUntilFileIsIndexed(fIndex, s2); |
| |
| fIndex.acquireReadLock(); |
| try { |
| IIndexFile[] indexFiles = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, |
| IndexLocationFactory.getWorkspaceIFL(h1)); |
| assertEquals(3, indexFiles.length); |
| for (IIndexFile indexFile : indexFiles) { |
| assertFalse(indexFile.hasPragmaOnceSemantics()); |
| assertEquals(1, fIndex.findIncludedBy(indexFile).length); |
| } |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| |
| // Change h1.h so that it has the pragma-once semantics. |
| final long t1 = System.currentTimeMillis(); |
| final String changedContents = contents[4].toString(); |
| ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() { |
| @Override |
| public void run(IProgressMonitor monitor) throws CoreException { |
| h1.setContents(new ByteArrayInputStream(changedContents.getBytes()), false, false, npm()); |
| h1.setLocalTimeStamp(t1 + 1000); |
| } |
| }, npm()); |
| waitForIndexer(); |
| |
| fIndex.acquireReadLock(); |
| try { |
| IIndexFile[] indexFiles = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, |
| IndexLocationFactory.getWorkspaceIFL(h1)); |
| assertEquals(1, indexFiles.length); |
| for (IIndexFile indexFile : indexFiles) { |
| assertTrue("Timestamp not ok", indexFile.getTimestamp() >= t1); |
| assertTrue(indexFile.hasPragmaOnceSemantics()); |
| // Included twice by h2.h and once by s1.cpp |
| assertEquals(2, fIndex.findIncludedBy(indexFile).length); |
| } |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| |
| // Change h1.h back to the original state without the pragma-once semantics. |
| final long t2 = System.currentTimeMillis(); |
| ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() { |
| @Override |
| public void run(IProgressMonitor monitor) throws CoreException { |
| h1.setContents(new ByteArrayInputStream(h1Contents.toString().getBytes()), false, false, npm()); |
| h1.setLocalTimeStamp(t2 + 2000); |
| } |
| }, npm()); |
| waitForIndexer(); |
| |
| fIndex.acquireReadLock(); |
| try { |
| IIndexFile[] indexFiles = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, |
| IndexLocationFactory.getWorkspaceIFL(h1)); |
| assertEquals(3, indexFiles.length); |
| for (IIndexFile indexFile : indexFiles) { |
| assertTrue("Timestamp not ok", indexFile.getTimestamp() >= t2); |
| assertFalse(indexFile.hasPragmaOnceSemantics()); |
| assertEquals(1, fIndex.findIncludedBy(indexFile).length); |
| } |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| // #pragma once |
| // #ifdef ABC |
| // int x = 5; |
| // #endif |
| |
| // #pragma once |
| // #include "b.hpp" |
| |
| // #pragma once |
| // #include "b.hpp" |
| |
| // #include "a1.hpp" |
| // #include "a2.hpp" |
| public void testSignificantMacrosWithPragmeOnceSemantic() throws Exception { |
| waitForIndexer(); |
| IProject prj = fProject.getProject(); |
| TestScannerProvider.sIncludes = new String[] { prj.getLocation().toOSString() }; |
| CharSequence[] contents = getContentsForTest(5); |
| |
| IFile b = createFile(prj, "b.hpp", contents[0].toString()); |
| IFile a1 = createFile(prj, "a1.hpp", contents[1].toString()); |
| IFile a2 = createFile(prj, "a2.hpp", contents[2].toString()); |
| |
| final IFile main = createFile(prj, "UltimateTest.cpp", contents[3].toString()); |
| |
| waitUntilFileIsIndexed(fIndex, b); |
| waitUntilFileIsIndexed(fIndex, a1); |
| waitUntilFileIsIndexed(fIndex, a2); |
| waitUntilFileIsIndexed(fIndex, main); |
| |
| fIndex.acquireReadLock(); |
| try { |
| IIndexFile[] indexFiles = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, |
| IndexLocationFactory.getWorkspaceIFL(main)); |
| |
| IIndexFile ultimateTestCppIdx = indexFiles[0]; |
| IIndexFile includes[] = new IIndexFile[3]; |
| includes[0] = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, IndexLocationFactory.getWorkspaceIFL(b))[0]; |
| includes[1] = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, IndexLocationFactory.getWorkspaceIFL(a1))[0]; |
| includes[2] = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, IndexLocationFactory.getWorkspaceIFL(a2))[0]; |
| |
| for (int i = 0; i < includes.length; i++) { |
| IIndexFile include = includes[i]; |
| outputUnresolvedIncludes(fIndex, include.getLocation(), ultimateTestCppIdx, new HashSet<IIndexFile>()); |
| } |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| // #pragma once |
| // #ifdef ABC |
| // int x = 5; |
| // #endif |
| |
| // #pragma once |
| // #include "b.hpp" |
| |
| // #pragma once |
| // #include "b.hpp" |
| |
| // #pragma once |
| // #include "b.hpp" |
| |
| // #pragma once |
| // #include "b.hpp" |
| |
| // #include "a1.hpp" |
| // #include "a2.hpp" |
| |
| // #include "a3.hpp" |
| // #include "a4.hpp" |
| public void testSignificantMacrosWithPragmeOnceFromIdxSemantic() throws Exception { |
| waitForIndexer(); |
| IProject prj = fProject.getProject(); |
| TestScannerProvider.sIncludes = new String[] { prj.getLocation().toOSString() }; |
| CharSequence[] contents = getContentsForTest(7); |
| |
| IFile b = createFile(prj, "b.hpp", contents[0].toString()); |
| IFile a1 = createFile(prj, "a1.hpp", contents[1].toString()); |
| IFile a2 = createFile(prj, "a2.hpp", contents[2].toString()); |
| IFile a3 = createFile(prj, "a3.hpp", contents[3].toString()); |
| IFile a4 = createFile(prj, "a4.hpp", contents[4].toString()); |
| |
| final IFile s1 = createFile(prj, "s1.cpp", contents[5].toString()); |
| final IFile s2 = createFile(prj, "s2.cpp", contents[6].toString()); |
| |
| waitUntilFileIsIndexed(fIndex, b); |
| waitUntilFileIsIndexed(fIndex, a1); |
| waitUntilFileIsIndexed(fIndex, a2); |
| waitUntilFileIsIndexed(fIndex, a3); |
| waitUntilFileIsIndexed(fIndex, a4); |
| waitUntilFileIsIndexed(fIndex, s1); |
| waitUntilFileIsIndexed(fIndex, s2); |
| |
| fIndex.acquireReadLock(); |
| try { |
| IIndexFile[] indexFiles = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, |
| IndexLocationFactory.getWorkspaceIFL(s1)); |
| |
| IIndexFile ultimateTestCppIdx = indexFiles[0]; |
| IIndexFile includes[] = new IIndexFile[5]; |
| includes[0] = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, IndexLocationFactory.getWorkspaceIFL(b))[0]; |
| includes[1] = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, IndexLocationFactory.getWorkspaceIFL(a1))[0]; |
| includes[2] = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, IndexLocationFactory.getWorkspaceIFL(a2))[0]; |
| includes[3] = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, IndexLocationFactory.getWorkspaceIFL(a3))[0]; |
| includes[4] = fIndex.getFiles(ILinkage.CPP_LINKAGE_ID, IndexLocationFactory.getWorkspaceIFL(a4))[0]; |
| |
| for (int i = 0; i < includes.length; i++) { |
| IIndexFile include = includes[i]; |
| outputUnresolvedIncludes(fIndex, include.getLocation(), ultimateTestCppIdx, new HashSet<IIndexFile>()); |
| } |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| private void outputUnresolvedIncludes(IIndex index, IIndexFileLocation ifl, IIndexFile ifile, |
| Set<IIndexFile> handled) throws CoreException { |
| if (ifile == null) { |
| Assert.fail(ifl.getURI() + " is not indexed"); |
| } else if (handled.add(ifile)) { |
| IIndexInclude[] includes = ifile.getIncludes(); |
| for (IIndexInclude inc : includes) { |
| if (inc.isActive()) { |
| if (inc.isResolved()) { |
| IIndexFile next = index.resolveInclude(inc); |
| outputUnresolvedIncludes(index, inc.getIncludesLocation(), next, handled); |
| } else { |
| Assert.fail("Unresolved inclusion: " + inc.getFullName() + " in file " |
| + inc.getIncludedByLocation().getURI()); |
| } |
| } |
| } |
| } |
| } |
| |
| private void standardCheckUpdateIncludes(IFile header, IFile s1, String tag) throws Exception { |
| fIndex.acquireReadLock(); |
| try { |
| assertEquals(1, fIndex.findBindings(tag.toCharArray(), IndexFilter.ALL_DECLARED, npm()).length); |
| |
| IIndexFile ifile = getIndexFile(header); |
| IIndexFile sfile = getIndexFile(s1); |
| IIndexInclude[] includes = fIndex.findIncludedBy(ifile); |
| assertEquals(1, includes.length); |
| assertEquals(s1.getFullPath().toString(), includes[0].getIncludedByLocation().getFullPath()); |
| assertEquals(header.getFullPath().toString(), includes[0].getIncludesLocation().getFullPath()); |
| assertTrue(includes[0].isActive()); |
| assertTrue(includes[0].isResolved()); |
| assertFalse(includes[0].isSystemInclude()); |
| |
| includes = fIndex.findIncludes(sfile); |
| assertEquals(3, includes.length); |
| assertEquals(header.getFullPath().toString(), includes[0].getIncludesLocation().getFullPath()); |
| assertEquals(s1.getFullPath().toString(), includes[0].getIncludedByLocation().getFullPath()); |
| assertTrue(includes[0].isActive()); |
| assertTrue(includes[0].isResolved()); |
| assertFalse(includes[0].isSystemInclude()); |
| |
| assertNull(includes[1].getIncludesLocation()); |
| assertEquals(s1.getFullPath().toString(), includes[1].getIncludedByLocation().getFullPath()); |
| assertTrue(includes[1].isActive()); |
| assertFalse(includes[1].isResolved()); |
| assertFalse(includes[1].isSystemInclude()); |
| |
| assertNull(includes[2].getIncludesLocation()); |
| assertEquals(s1.getFullPath().toString(), includes[2].getIncludedByLocation().getFullPath()); |
| assertFalse(includes[2].isActive()); |
| assertFalse(includes[2].isResolved()); |
| assertFalse(includes[2].isSystemInclude()); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| private void checkUpdateIncludes1(IFile header, IFile s1, String tag) throws Exception { |
| fIndex.acquireReadLock(); |
| try { |
| assertEquals(1, fIndex.findBindings(tag.toCharArray(), IndexFilter.ALL_DECLARED, npm()).length); |
| |
| IIndexFile ifile = getIndexFile(header); |
| IIndexFile sfile = getIndexFile(s1); |
| IIndexInclude[] includes = fIndex.findIncludedBy(ifile); |
| assertEquals(0, includes.length); |
| |
| includes = fIndex.findIncludes(sfile); |
| assertEquals(2, includes.length); |
| |
| assertNull(includes[0].getIncludesLocation()); |
| assertEquals(s1.getFullPath().toString(), includes[0].getIncludedByLocation().getFullPath()); |
| assertTrue(includes[0].isActive()); |
| assertFalse(includes[0].isResolved()); |
| assertTrue(includes[0].isSystemInclude()); |
| |
| assertNull(includes[1].getIncludesLocation()); |
| assertEquals(s1.getFullPath().toString(), includes[1].getIncludedByLocation().getFullPath()); |
| assertFalse(includes[1].isActive()); |
| assertFalse(includes[1].isResolved()); |
| assertTrue(includes[1].isSystemInclude()); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| private void checkUpdateIncludes2(IFile header, IFile s1, String tag) throws Exception { |
| fIndex.acquireReadLock(); |
| try { |
| assertEquals(1, fIndex.findBindings(tag.toCharArray(), IndexFilter.ALL_DECLARED, npm()).length); |
| |
| IIndexFile ifile = getIndexFile(header); |
| IIndexFile sfile = getIndexFile(s1); |
| IIndexInclude[] includes = fIndex.findIncludedBy(ifile); |
| assertEquals(1, includes.length); |
| assertEquals(s1.getFullPath().toString(), includes[0].getIncludedByLocation().getFullPath()); |
| assertEquals(header.getFullPath().toString(), includes[0].getIncludesLocation().getFullPath()); |
| assertTrue(includes[0].isActive()); |
| assertTrue(includes[0].isResolved()); |
| assertTrue(includes[0].isSystemInclude()); |
| |
| includes = fIndex.findIncludes(sfile); |
| assertEquals(2, includes.length); |
| assertEquals(header.getFullPath().toString(), includes[0].getIncludesLocation().getFullPath()); |
| assertEquals(s1.getFullPath().toString(), includes[0].getIncludedByLocation().getFullPath()); |
| assertTrue(includes[0].isActive()); |
| assertTrue(includes[0].isResolved()); |
| assertTrue(includes[0].isSystemInclude()); |
| |
| assertNull(includes[1].getIncludesLocation()); |
| assertEquals(s1.getFullPath().toString(), includes[1].getIncludedByLocation().getFullPath()); |
| assertFalse(includes[1].isActive()); |
| assertFalse(includes[1].isResolved()); |
| assertTrue(includes[1].isSystemInclude()); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| |
| private void checkUpdateIncludes3(IFile header, IFile s1, String tag) throws Exception { |
| fIndex.acquireReadLock(); |
| try { |
| assertEquals(1, fIndex.findBindings(tag.toCharArray(), IndexFilter.ALL_DECLARED, npm()).length); |
| |
| IIndexFile ifile = getIndexFile(header); |
| IIndexFile sfile = getIndexFile(s1); |
| IIndexInclude[] includes = fIndex.findIncludedBy(ifile); |
| assertEquals(1, includes.length); |
| assertEquals(s1.getFullPath().toString(), includes[0].getIncludedByLocation().getFullPath()); |
| assertEquals(header.getFullPath().toString(), includes[0].getIncludesLocation().getFullPath()); |
| assertTrue(includes[0].isActive()); |
| assertTrue(includes[0].isResolved()); |
| assertFalse(includes[0].isSystemInclude()); |
| |
| includes = fIndex.findIncludes(sfile); |
| assertEquals(2, includes.length); |
| assertEquals(header.getFullPath().toString(), includes[0].getIncludesLocation().getFullPath()); |
| assertEquals(s1.getFullPath().toString(), includes[0].getIncludedByLocation().getFullPath()); |
| assertTrue(includes[0].isActive()); |
| assertTrue(includes[0].isResolved()); |
| assertFalse(includes[0].isSystemInclude()); |
| |
| assertNull(includes[1].getIncludesLocation()); |
| assertEquals(s1.getFullPath().toString(), includes[1].getIncludedByLocation().getFullPath()); |
| assertTrue(includes[1].isActive()); |
| assertFalse(includes[1].isResolved()); |
| assertFalse(includes[1].isSystemInclude()); |
| } finally { |
| fIndex.releaseReadLock(); |
| } |
| } |
| } |
