1
/*******************************************************************************
2
* Copyright (c) 2004, 2010 IBM Corporation and others.
3
* All rights reserved. This program and the accompanying materials
4
* are made available under the terms of the Eclipse Public License v1.0
5
* which accompanies this distribution, and is available at
6
* http://www.eclipse.org/legal/epl-v10.html
9
* IBM - Initial API and implementation
10
* Markus Schorn (Wind River Systems)
11
*******************************************************************************/
12
package org.eclipse.cdt.ui.tests.text.selection;
14
import java.io.ByteArrayInputStream;
16
import java.io.InputStream;
17
import java.io.StringWriter;
18
import java.io.Writer;
20
import junit.framework.Test;
21
import junit.framework.TestSuite;
23
import org.eclipse.core.resources.IFile;
24
import org.eclipse.core.resources.IFolder;
25
import org.eclipse.core.resources.IProject;
26
import org.eclipse.core.resources.IResource;
27
import org.eclipse.core.resources.IWorkspace;
28
import org.eclipse.core.resources.ResourcesPlugin;
29
import org.eclipse.core.runtime.CoreException;
30
import org.eclipse.core.runtime.IPath;
31
import org.eclipse.core.runtime.IStatus;
32
import org.eclipse.core.runtime.NullProgressMonitor;
33
import org.eclipse.core.runtime.Path;
34
import org.eclipse.core.runtime.Status;
35
import org.eclipse.jface.text.IDocument;
36
import org.eclipse.jface.text.ITextSelection;
37
import org.eclipse.jface.text.TextSelection;
38
import org.eclipse.jface.viewers.ISelection;
39
import org.eclipse.ui.IEditorPart;
40
import org.eclipse.ui.IWorkbenchPage;
41
import org.eclipse.ui.PartInitException;
42
import org.eclipse.ui.PlatformUI;
43
import org.eclipse.ui.part.FileEditorInput;
44
import org.eclipse.ui.texteditor.AbstractTextEditor;
45
import org.eclipse.ui.texteditor.ITextEditor;
47
import org.eclipse.cdt.core.CCorePlugin;
48
import org.eclipse.cdt.core.dom.IPDOMManager;
49
import org.eclipse.cdt.core.dom.ast.IASTName;
50
import org.eclipse.cdt.core.dom.ast.IASTNode;
51
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
52
import org.eclipse.cdt.core.model.ICProject;
53
import org.eclipse.cdt.core.model.ILanguage;
54
import org.eclipse.cdt.core.model.ITranslationUnit;
55
import org.eclipse.cdt.core.testplugin.CProjectHelper;
56
import org.eclipse.cdt.core.testplugin.FileManager;
57
import org.eclipse.cdt.ui.CUIPlugin;
58
import org.eclipse.cdt.ui.testplugin.EditorTestHelper;
59
import org.eclipse.cdt.ui.tests.BaseUITestCase;
61
import org.eclipse.cdt.internal.core.dom.parser.ASTNode;
62
import org.eclipse.cdt.internal.core.model.ASTCache.ASTRunnable;
63
import org.eclipse.cdt.internal.core.parser.ParserException;
65
import org.eclipse.cdt.internal.ui.editor.ASTProvider;
66
import org.eclipse.cdt.internal.ui.search.actions.OpenDeclarationsAction;
69
* It is required to test the selection performance independent of the indexer to make sure that the DOM
70
* is functioning properly.
72
* Indexer bugs can drastically influence the correctness of these tests so the indexer has to be off when
77
public class CPPSelectionTestsNoIndexer extends BaseUITestCase {
79
private static final String INDEX_FILE_ID = "2946365241"; //$NON-NLS-1$
80
static NullProgressMonitor monitor;
81
static IWorkspace workspace;
82
static IProject project;
83
static ICProject cPrj;
84
static FileManager fileManager;
85
static boolean disabledHelpContributions = false;
87
static void initProject() {
88
if (project != null) {
92
//(CCorePlugin.getDefault().getCoreModel().getIndexManager()).reset();
93
monitor = new NullProgressMonitor();
95
workspace = ResourcesPlugin.getWorkspace();
98
cPrj = CProjectHelper.createCCProject("CPPSelectionTestsNoIndexer", "bin", IPDOMManager.ID_NO_INDEXER); //$NON-NLS-1$ //$NON-NLS-2$
100
project = cPrj.getProject();
102
IPath pathLoc = CCorePlugin.getDefault().getStateLocation();
103
File indexFile = new File(pathLoc.append(INDEX_FILE_ID + ".index").toOSString()); //$NON-NLS-1$
104
if (indexFile.exists())
106
} catch (CoreException e) {
110
fail("Unable to create project"); //$NON-NLS-1$
112
//Create file manager
113
fileManager = new FileManager();
116
public CPPSelectionTestsNoIndexer() {
123
public CPPSelectionTestsNoIndexer(String name) {
127
public static Test suite() {
128
TestSuite suite= suite(CPPSelectionTestsNoIndexer.class, "_");
129
suite.addTest(new CPPSelectionTestsNoIndexer("cleanupProject")); //$NON-NLS-1$
133
public void cleanupProject() throws Exception {
136
project.delete(true, false, monitor);
137
} catch (CoreException e) {
139
project.delete(true, false, monitor);
141
catch (CoreException e1) {}
148
protected void setUp() throws Exception {
151
OpenDeclarationsAction.sIsJUnitTest= true;
155
protected void tearDown() throws Exception {
156
if (project == null || !project.exists())
161
IResource[] members = project.members();
162
for (IResource member : members) {
163
if (member.getName().equals(".project") || member.getName().equals(".cproject")) //$NON-NLS-1$ //$NON-NLS-2$
165
if (member.getName().equals(".settings"))
168
member.delete(false, monitor);
169
} catch (Throwable e) {
175
protected IFile importFile(String fileName, String contents) throws Exception{
177
IFile file = project.getProject().getFile(fileName);
179
InputStream stream = new ByteArrayInputStream(contents.getBytes());
180
//Create file input stream
182
file.setContents(stream, false, false, monitor);
184
file.create(stream, false, monitor);
186
fileManager.addFile(file);
191
protected IFile importFileWithLink(String fileName, String contents) throws Exception{
193
IFile file = project.getProject().getFile(fileName);
195
IPath location = new Path(project.getLocation().removeLastSegments(1).toOSString() + File.separator + fileName);
197
File linkFile = new File(location.toOSString());
198
if (!linkFile.exists()) {
199
linkFile.createNewFile();
202
file.createLink(location, IResource.ALLOW_MISSING_LOCAL, null);
204
InputStream stream = new ByteArrayInputStream(contents.getBytes());
205
//Create file input stream
207
file.setContents(stream, false, false, monitor);
209
file.create(stream, false, monitor);
211
fileManager.addFile(file);
216
protected IFile importFileInsideLinkedFolder(String fileName, String contents, String folderName) throws Exception{
217
IFolder linkedFolder = project.getFolder(folderName);
218
IPath folderLocation = new Path(project.getLocation().toOSString() + File.separator + folderName + "_this_is_linked"); //$NON-NLS-1$
219
IFolder actualFolder = project.getFolder(folderName + "_this_is_linked"); //$NON-NLS-1$
220
if (!actualFolder.exists())
221
actualFolder.create(true, true, monitor);
223
linkedFolder.createLink(folderLocation, IResource.NONE, monitor);
225
actualFolder.delete(true, false, monitor);
227
IFile file = linkedFolder.getFile(fileName);
229
InputStream stream = new ByteArrayInputStream(contents.getBytes());
230
//Create file input stream
232
file.setContents(stream, false, false, monitor);
234
file.create(stream, false, monitor);
236
fileManager.addFile(file);
241
protected IASTNode testF3(IFile file, int offset) throws ParserException, CoreException {
242
return testF3(file, offset, 0);
245
protected IASTNode testF3(IFile file, int offset, int length) throws ParserException, CoreException {
247
throw new ParserException("offset can not be less than 0 and was " + offset); //$NON-NLS-1$
249
IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
250
IEditorPart part = null;
252
part = page.openEditor(new FileEditorInput(file), "org.eclipse.cdt.ui.editor.CEditor"); //$NON-NLS-1$
253
EditorTestHelper.joinReconciler(EditorTestHelper.getSourceViewer((AbstractTextEditor) part), 100, 5000, 10);
254
} catch (PartInitException e) {
258
if (part instanceof ITextEditor) {
259
ITextEditor editor= (ITextEditor) part;
260
editor.getSelectionProvider().setSelection(new TextSelection(offset,length));
262
final OpenDeclarationsAction action = (OpenDeclarationsAction) ((AbstractTextEditor) part).getAction("OpenDeclarations"); //$NON-NLS-1$
265
// the action above should highlight the declaration, so now retrieve it and use that selection to get the IASTName selected on the TU
266
ISelection sel = ((AbstractTextEditor)part).getSelectionProvider().getSelection();
268
final IASTName[] result= { null };
269
if (sel instanceof ITextSelection) {
270
final ITextSelection textSel = (ITextSelection)sel;
271
ITranslationUnit tu= CUIPlugin.getDefault().getWorkingCopyManager().getWorkingCopy(editor.getEditorInput());
272
IStatus ok= ASTProvider.getASTProvider().runOnAST(tu, ASTProvider.WAIT_IF_OPEN, monitor, new ASTRunnable() {
273
public IStatus runOnAST(ILanguage language, IASTTranslationUnit ast) throws CoreException {
274
result[0]= ast.getNodeSelector(null).findName(textSel.getOffset(), textSel.getLength());
275
return Status.OK_STATUS;
278
assertTrue(ok.isOK());
286
private void assertContents(String code, int offset, String expected) {
287
assertEquals(expected, code.substring(offset, offset + expected.length()));
290
public void testBug93281() throws Exception {
291
StringBuffer buffer = new StringBuffer();
292
buffer.append("class Point{ \n"); //$NON-NLS-1$
293
buffer.append("public: \n"); //$NON-NLS-1$
294
buffer.append("Point(): xCoord(0){} \n"); //$NON-NLS-1$
295
buffer.append("Point& operator=(const Point &rhs){return *this;} // line A\n"); //$NON-NLS-1$
296
buffer.append("void* operator new [ ] (unsigned int);\n"); //$NON-NLS-1$
297
buffer.append("private: \n"); //$NON-NLS-1$
298
buffer.append("int xCoord; \n"); //$NON-NLS-1$
299
buffer.append("}; \n"); //$NON-NLS-1$
300
buffer.append("static const Point zero;\n"); //$NON-NLS-1$
301
buffer.append("int main(int argc, char **argv) { \n"); //$NON-NLS-1$
302
buffer.append("Point *p2 = new Point(); \n"); //$NON-NLS-1$
303
buffer.append("p2-> operator // /* operator */ // F3 in the middle \n"); //$NON-NLS-1$
304
buffer.append("//of \"operator\" should work\n"); //$NON-NLS-1$
305
buffer.append("// \\n"); //$NON-NLS-1$
306
buffer.append("/* */\n"); //$NON-NLS-1$
307
buffer.append("=(zero); // line B\n"); //$NON-NLS-1$
308
buffer.append("p2->operator /* oh yeah */ new // F3 in the middle of \"operator\"\n"); //$NON-NLS-1$
309
buffer.append("// should work\n"); //$NON-NLS-1$
310
buffer.append("//\n"); //$NON-NLS-1$
311
buffer.append("[ /* sweet */ ] //\n"); //$NON-NLS-1$
312
buffer.append("(2);\n"); //$NON-NLS-1$
313
buffer.append("return (0); \n"); //$NON-NLS-1$
314
buffer.append("}\n"); //$NON-NLS-1$
316
String code = buffer.toString();
317
IFile file = importFile("test93281.cpp", code); //$NON-NLS-1$
319
int offset = code.indexOf("p2->operator") + 6; //$NON-NLS-1$
320
IASTNode node = testF3(file, offset);
322
assertTrue(node instanceof IASTName);
323
assertEquals("operator new[]", ((IASTName)node).toString()); //$NON-NLS-1$
324
assertEquals(183, ((ASTNode)node).getOffset());
325
assertEquals(16, ((ASTNode)node).getLength());
327
offset = code.indexOf("p2-> operator") + 11; //$NON-NLS-1$
328
node = testF3(file, offset);
330
assertTrue(node instanceof IASTName);
331
assertEquals("operator =", ((IASTName)node).toString()); //$NON-NLS-1$
332
assertEquals(121, ((ASTNode)node).getOffset());
333
assertEquals(9, ((ASTNode)node).getLength());
336
public void testBasicDefinition() throws Exception {
337
StringBuffer buffer = new StringBuffer();
338
buffer.append("extern int MyInt; // def is in another file \n"); //$NON-NLS-1$
339
buffer.append("extern const int MyConst; // def is in another file \n"); //$NON-NLS-1$
340
buffer.append("void MyFunc(int); // often used in header files\n"); //$NON-NLS-1$
341
buffer.append("struct MyStruct; // often used in header files\n"); //$NON-NLS-1$
342
buffer.append("typedef int NewInt; // a normal typedef statement\n"); //$NON-NLS-1$
343
buffer.append("class MyClass; // often used in header files\n"); //$NON-NLS-1$
344
buffer.append("int MyInt;\n"); //$NON-NLS-1$
345
buffer.append("extern const int MyConst = 42;\n"); //$NON-NLS-1$
346
buffer.append("void MyFunc(int a) { cout << a << endl; }\n"); //$NON-NLS-1$
347
buffer.append("struct MyStruct { int Member1; int Member2; };\n"); //$NON-NLS-1$
348
buffer.append("class MyClass { int MemberVar; };\n"); //$NON-NLS-1$
350
String code = buffer.toString();
351
IFile file = importFile("testBasicDefinition.cpp", code); //$NON-NLS-1$
353
int offset = code.indexOf("MyInt") + 2; //$NON-NLS-1$
354
int defOffset = code.indexOf("MyInt", offset) + 2; //$NON-NLS-1$
355
IASTNode def = testF3(file, offset);
356
IASTNode decl = testF3(file, defOffset);
357
assertTrue(def instanceof IASTName);
358
assertTrue(decl instanceof IASTName);
359
assertEquals("MyInt", ((IASTName) decl).toString()); //$NON-NLS-1$
360
assertEquals(11, ((ASTNode) decl).getOffset());
361
assertEquals(5, ((ASTNode) decl).getLength());
362
assertEquals("MyInt", ((IASTName) def).toString()); //$NON-NLS-1$
363
assertEquals(330, ((ASTNode) def).getOffset());
364
assertEquals(5, ((ASTNode) def).getLength());
366
offset= code.indexOf("MyConst") + 2;
367
defOffset= code.indexOf("MyConst", offset) + 2;
368
def = testF3(file, offset);
369
decl = testF3(file, defOffset);
370
assertTrue(def instanceof IASTName);
371
assertTrue(decl instanceof IASTName);
372
assertEquals("MyConst", ((IASTName) decl).toString()); //$NON-NLS-1$
373
assertEquals(69, ((ASTNode) decl).getOffset());
374
assertEquals(7, ((ASTNode) decl).getLength());
375
assertEquals("MyConst", ((IASTName) def).toString()); //$NON-NLS-1$
376
assertEquals(354, ((ASTNode) def).getOffset());
377
assertEquals(7, ((ASTNode) def).getLength());
379
offset= code.indexOf("MyFunc") + 2;
380
defOffset= code.indexOf("MyFunc", offset) + 2;
381
def = testF3(file, offset);
382
decl = testF3(file, defOffset);
383
assertTrue(def instanceof IASTName);
384
assertTrue(decl instanceof IASTName);
385
assertEquals("MyFunc", ((IASTName) decl).toString()); //$NON-NLS-1$
386
assertEquals(115, ((ASTNode) decl).getOffset());
387
assertEquals(6, ((ASTNode) decl).getLength());
388
assertEquals("MyFunc", ((IASTName) def).toString()); //$NON-NLS-1$
389
assertEquals(373, ((ASTNode) def).getOffset());
390
assertEquals(6, ((ASTNode) def).getLength());
392
offset= code.indexOf("MyStruct") + 2;
393
defOffset= code.indexOf("MyStruct", offset) + 2;
394
def = testF3(file, offset);
395
decl = testF3(file, defOffset);
396
assertTrue(def instanceof IASTName);
397
assertTrue(decl instanceof IASTName);
398
assertEquals("MyStruct", ((IASTName) decl).toString()); //$NON-NLS-1$
399
assertEquals(417, ((ASTNode) decl).getOffset());
400
assertEquals(8, ((ASTNode) decl).getLength());
401
assertEquals("MyStruct", ((IASTName) def).toString()); //$NON-NLS-1$
402
assertEquals(417, ((ASTNode) def).getOffset());
403
assertEquals(8, ((ASTNode) def).getLength());
405
offset= code.indexOf("MyClass") + 2;
406
defOffset= code.indexOf("MyClass", offset) + 2;
407
def = testF3(file, offset);
408
decl = testF3(file, defOffset);
409
assertTrue(def instanceof IASTName);
410
assertTrue(decl instanceof IASTName);
411
assertEquals("MyClass", ((IASTName) decl).toString()); //$NON-NLS-1$
412
assertEquals(463, ((ASTNode) decl).getOffset());
413
assertEquals(7, ((ASTNode) decl).getLength());
414
assertEquals("MyClass", ((IASTName) def).toString()); //$NON-NLS-1$
415
assertEquals(463, ((ASTNode) def).getOffset());
416
assertEquals(7, ((ASTNode) def).getLength());
419
public void testBug95224() throws Exception{
420
Writer writer = new StringWriter();
421
writer.write("class A{\n"); //$NON-NLS-1$
422
writer.write("A();\n"); //$NON-NLS-1$
423
writer.write("A(const A&); // open definition on A finds class A\n"); //$NON-NLS-1$
424
writer.write("~A(); // open definition on A finds nothing\n"); //$NON-NLS-1$
425
writer.write("};\n"); //$NON-NLS-1$
427
String code = writer.toString();
428
IFile file = importFile("testBug95224.cpp", code); //$NON-NLS-1$
430
int offset = code.indexOf("A(); // open definition "); //$NON-NLS-1$
431
IASTNode decl = testF3(file, offset);
432
assertTrue(decl instanceof IASTName);
433
assertEquals("~A", ((IASTName) decl).toString()); //$NON-NLS-1$
434
assertEquals(65, ((ASTNode) decl).getOffset());
435
assertEquals(2, ((ASTNode) decl).getLength());
438
public void testBasicTemplateInstance() throws Exception{
439
Writer writer = new StringWriter();
440
writer.write("namespace N{ \n"); //$NON-NLS-1$
441
writer.write(" template < class T > class AAA { T _t; };\n"); //$NON-NLS-1$
442
writer.write("}; \n"); //$NON-NLS-1$
443
writer.write("N::AAA<int> a; \n"); //$NON-NLS-1$
445
String code = writer.toString();
446
IFile file = importFile("testBasicTemplateInstance.cpp", code); //$NON-NLS-1$
448
int offset = code.indexOf("AAA<int>"); //$NON-NLS-1$
449
IASTNode decl1 = testF3(file, offset, 3);
450
assertTrue(decl1 instanceof IASTName);
451
assertEquals("AAA", ((IASTName) decl1).toString()); //$NON-NLS-1$
452
assertEquals(74, ((ASTNode) decl1).getOffset());
453
assertEquals(3, ((ASTNode) decl1).getLength());
455
IASTNode decl2 = testF3(file, offset, 8);
456
assertTrue(decl2 instanceof IASTName);
457
assertEquals("AAA", ((IASTName) decl2).toString()); //$NON-NLS-1$
458
assertEquals(74, ((ASTNode) decl2).getOffset());
459
assertEquals(3, ((ASTNode) decl2).getLength());
462
public void testBug86829A() throws Exception {
463
StringBuffer buffer = new StringBuffer();
464
buffer.append("class X {\n"); //$NON-NLS-1$
465
buffer.append("public:\n"); //$NON-NLS-1$
466
buffer.append("X(int); // openReferences fails to find the constructor in g()\n"); //$NON-NLS-1$
467
buffer.append("};\n"); //$NON-NLS-1$
468
buffer.append("X f(X);\n"); //$NON-NLS-1$
469
buffer.append("void g()\n"); //$NON-NLS-1$
470
buffer.append("{\n"); //$NON-NLS-1$
471
buffer.append("X b = f(X(2)); // openDeclarations on X(int) finds the class and not \n"); //$NON-NLS-1$
472
buffer.append("}\n"); //$NON-NLS-1$
474
String code = buffer.toString();
475
IFile file = importFile("testBug86829A.cpp", code); //$NON-NLS-1$
477
int offset = code.indexOf("X(2)"); //$NON-NLS-1$
478
IASTNode decl = testF3(file, offset);
479
assertTrue(decl instanceof IASTName);
480
assertEquals("X", ((IASTName) decl).toString()); //$NON-NLS-1$
481
assertEquals(18, ((ASTNode) decl).getOffset());
482
assertEquals(1, ((ASTNode) decl).getLength());
485
public void testBug86829B() throws Exception {
486
StringBuffer buffer = new StringBuffer();
487
buffer.append("class X {\n"); //$NON-NLS-1$
488
buffer.append("public:\n"); //$NON-NLS-1$
489
buffer.append("operator int();\n"); //$NON-NLS-1$
490
buffer.append("};\n"); //$NON-NLS-1$
491
buffer.append("class Y {\n"); //$NON-NLS-1$
492
buffer.append("public:\n"); //$NON-NLS-1$
493
buffer.append("operator X();\n"); //$NON-NLS-1$
494
buffer.append("};\n"); //$NON-NLS-1$
495
buffer.append("void test() {\n");
496
buffer.append("Y a;\n"); //$NON-NLS-1$
497
buffer.append("int c = X(a); // OK: a.operator X().operator int()\n"); //$NON-NLS-1$
498
buffer.append("}\n"); //$NON-NLS-1$
500
String code = buffer.toString();
501
IFile file = importFile("testBug86829B.cpp", code); //$NON-NLS-1$
503
int offset = code.indexOf("X(a);"); //$NON-NLS-1$
504
IASTNode decl = testF3(file, offset);
505
assertTrue(decl instanceof IASTName);
506
assertEquals("X", ((IASTName) decl).toString()); //$NON-NLS-1$
507
assertEquals(6, ((ASTNode) decl).getOffset());
508
assertEquals(1, ((ASTNode) decl).getLength());
511
// taken from C++ spec 3.1-3:
513
// all but one of the following are definitions:
515
extern const int c = 1; // defines c
516
int f(int x) { return x+a; } // defines f and defines x
517
struct S { int a; int b; }; // defines S, S::a, and S::b
518
struct X { // defines X
519
int x; // defines nonstatic data member x
520
static int y; // declares static data member y
521
X(): x(0) { } // defines a constructor of X
523
int X::y = 1; // defines X::y
524
enum { up, down }; // defines up and down
525
namespace N { int d; } // defines N and N::d
526
namespace N1 = N; // defines N1
527
X anX; // defines anX, implicitly calls X()
528
// whereas these are just declarations:
529
extern int a; // declares a
530
extern const int c; // declares c
531
int f(int); // declares f
532
struct S; // declares S
533
typedef int Int; // declares Int
534
extern X anotherX; // declares anotherX
535
using N::d; // declares N::d
537
public void testCPPSpecDeclsDefs() throws Exception {
538
StringBuffer buffer = new StringBuffer();
539
buffer.append("int a; // defines a\n"); //$NON-NLS-1$
540
buffer.append("extern const int c = 1; // defines c\n"); //$NON-NLS-1$
541
buffer.append("int f(int x) { return x+a; } // defines f and defines x\n"); //$NON-NLS-1$
542
buffer.append("struct S { int a; int b; }; // defines S, S::a, and S::b\n"); //$NON-NLS-1$
543
buffer.append("struct X { // defines X\n"); //$NON-NLS-1$
544
buffer.append("int x; // defines nonstatic data member x\n"); //$NON-NLS-1$
545
buffer.append("static int y; // declares static data member y\n"); //$NON-NLS-1$
546
buffer.append("X(): x(0) { } // defines a constructor of X\n"); //$NON-NLS-1$
547
buffer.append("};\n"); //$NON-NLS-1$
548
buffer.append("int X::y = 1; // defines X::y\n"); //$NON-NLS-1$
549
buffer.append("enum { up, down }; // defines up and down\n"); //$NON-NLS-1$
550
buffer.append("namespace N { int d; } // defines N and N::d\n"); //$NON-NLS-1$
551
buffer.append("namespace N1 = N; // defines N1\n"); //$NON-NLS-1$
552
buffer.append("X anX; // defines anX\n"); //$NON-NLS-1$
553
buffer.append("extern int a; // declares a\n"); //$NON-NLS-1$
554
buffer.append("extern const int c; // declares c\n"); //$NON-NLS-1$
555
buffer.append("int f(int y); // declar f\n"); //$NON-NLS-1$
556
buffer.append("struct S; // declares S\n"); //$NON-NLS-1$
557
buffer.append("typedef int Int; // declares Int\n"); //$NON-NLS-1$
558
buffer.append("extern X anotherX; // declares anotherX\n"); //$NON-NLS-1$
559
buffer.append("using N::d; // declares N::d\n"); //$NON-NLS-1$
561
String code = buffer.toString();
562
IFile file = importFile("testCPPSpecDeclsDefs.cpp", code); //$NON-NLS-1$
563
int offset = code.indexOf("a; // defines a"); //$NON-NLS-1$
564
IASTNode decl = testF3(file, offset);
565
assertTrue(decl instanceof IASTName);
566
assertEquals("a", ((IASTName) decl).toString()); //$NON-NLS-1$
567
assertEquals(512, ((ASTNode) decl).getOffset());
568
assertEquals(1, ((ASTNode) decl).getLength());
570
offset = code.indexOf("c = 1; // defines c"); //$NON-NLS-1$
571
decl = testF3(file, offset);
572
assertTrue(decl instanceof IASTName);
573
assertEquals("c", ((IASTName) decl).toString()); //$NON-NLS-1$
574
assertEquals(546, ((ASTNode) decl).getOffset());
575
assertEquals(1, ((ASTNode) decl).getLength());
577
offset = code.indexOf("f(int x) { return x+a; } // defines f and defines x"); //$NON-NLS-1$
578
decl = testF3(file, offset);
579
assertTrue(decl instanceof IASTName);
580
assertEquals("f", ((IASTName) decl).toString()); //$NON-NLS-1$
581
assertEquals(567, ((ASTNode) decl).getOffset());
582
assertEquals(1, ((ASTNode) decl).getLength());
584
offset = code.indexOf("x) { return x+a; } // defines f and defines x"); //$NON-NLS-1$
585
decl = testF3(file, offset);
586
assertTrue(decl instanceof IASTName);
587
assertEquals("x", ((IASTName) decl).toString()); //$NON-NLS-1$
588
assertEquals(67, ((ASTNode) decl).getOffset());
589
assertEquals(1, ((ASTNode) decl).getLength());
591
offset = code.indexOf("x+a; } // defines f and defines x"); //$NON-NLS-1$
592
decl = testF3(file, offset);
593
assertTrue(decl instanceof IASTName);
594
assertEquals("x", ((IASTName) decl).toString()); //$NON-NLS-1$
595
assertEquals(67, ((ASTNode) decl).getOffset());
596
assertEquals(1, ((ASTNode) decl).getLength());
598
offset = code.indexOf("x+a; } // defines f and defines x"); //$NON-NLS-1$
599
decl = testF3(file, offset);
600
assertTrue(decl instanceof IASTName);
601
assertEquals("x", ((IASTName) decl).toString()); //$NON-NLS-1$
602
assertEquals(67, ((ASTNode) decl).getOffset());
603
assertEquals(1, ((ASTNode) decl).getLength());
605
offset = code.indexOf("a; } // defines f and defines x"); //$NON-NLS-1$
606
decl = testF3(file, offset);
607
assertTrue(decl instanceof IASTName);
608
assertEquals("a", ((IASTName) decl).toString()); //$NON-NLS-1$
609
assertEquals(4, ((ASTNode) decl).getOffset());
610
assertEquals(1, ((ASTNode) decl).getLength());
612
offset = code.indexOf("S { int a; int b; }; // defines S, S::a, and S::b"); //$NON-NLS-1$
613
decl = testF3(file, offset);
614
assertTrue(decl instanceof IASTName);
615
assertEquals("S", ((IASTName) decl).toString()); //$NON-NLS-1$
616
assertEquals(120, ((ASTNode) decl).getOffset());
617
assertEquals(1, ((ASTNode) decl).getLength());
619
offset = code.indexOf("a; int b; }; // defines S, S::a, and S::b"); //$NON-NLS-1$
620
decl = testF3(file, offset);
621
assertTrue(decl instanceof IASTName);
622
assertEquals("a", ((IASTName) decl).toString()); //$NON-NLS-1$
623
assertEquals(128, ((ASTNode) decl).getOffset());
624
assertEquals(1, ((ASTNode) decl).getLength());
626
offset = code.indexOf("b; }; // defines S, S::a, and S::b"); //$NON-NLS-1$
627
decl = testF3(file, offset);
628
assertTrue(decl instanceof IASTName);
629
assertEquals("b", ((IASTName) decl).toString()); //$NON-NLS-1$
630
assertEquals(135, ((ASTNode) decl).getOffset());
631
assertEquals(1, ((ASTNode) decl).getLength());
633
offset = code.indexOf("X { // defines X"); //$NON-NLS-1$
634
decl = testF3(file, offset);
635
assertTrue(decl instanceof IASTName);
636
assertEquals("X", ((IASTName) decl).toString()); //$NON-NLS-1$
637
assertEquals(177, ((ASTNode) decl).getOffset());
638
assertEquals(1, ((ASTNode) decl).getLength());
640
offset = code.indexOf("x; // defines nonstatic data member x"); //$NON-NLS-1$
641
decl = testF3(file, offset);
642
assertTrue(decl instanceof IASTName);
643
assertEquals("x", ((IASTName) decl).toString()); //$NON-NLS-1$
644
assertEquals(198, ((ASTNode) decl).getOffset());
645
assertEquals(1, ((ASTNode) decl).getLength());
648
offset = code.indexOf("y; // declares static data member y"); //$NON-NLS-1$
649
def = testF3(file, offset);
650
assertTrue(def instanceof IASTName);
651
assertEquals("y", ((IASTName) def).toString()); //$NON-NLS-1$
652
assertEquals(337, ((ASTNode) def).getOffset());
653
assertEquals(1, ((ASTNode) def).getLength());
655
offset = code.indexOf("X(): x(0) { } // defines a constructor of X"); //$NON-NLS-1$
656
decl = testF3(file, offset);
657
assertTrue(decl instanceof IASTName);
658
assertEquals("X", ((IASTName) decl).toString()); //$NON-NLS-1$
659
assertEquals(283, ((ASTNode) decl).getOffset());
660
assertEquals(1, ((ASTNode) decl).getLength());
662
offset = code.indexOf("x(0) { } // defines a constructor of X"); //$NON-NLS-1$
663
decl = testF3(file, offset);
664
assertTrue(decl instanceof IASTName);
665
assertEquals("x", ((IASTName) decl).toString()); //$NON-NLS-1$
666
assertEquals(198, ((ASTNode) decl).getOffset());
667
assertEquals(1, ((ASTNode) decl).getLength());
669
offset = code.indexOf("X::y = 1; // defines X::y"); //$NON-NLS-1$
670
decl = testF3(file, offset);
671
assertTrue(decl instanceof IASTName);
672
assertEquals("X", ((IASTName) decl).toString()); //$NON-NLS-1$
673
assertEquals(177, ((ASTNode) decl).getOffset());
674
assertEquals(1, ((ASTNode) decl).getLength());
676
offset = code.indexOf("y = 1; // defines X::y"); //$NON-NLS-1$
677
decl = testF3(file, offset);
678
assertTrue(decl instanceof IASTName);
679
assertEquals("y", ((IASTName) decl).toString()); //$NON-NLS-1$
680
assertEquals(247, ((ASTNode) decl).getOffset());
681
assertEquals(1, ((ASTNode) decl).getLength());
683
offset = code.indexOf("up, down }; // defines up and down"); //$NON-NLS-1$
684
decl = testF3(file, offset);
685
assertTrue(decl instanceof IASTName);
686
assertEquals("up", ((IASTName) decl).toString()); //$NON-NLS-1$
687
assertEquals(367, ((ASTNode) decl).getOffset());
688
assertEquals(2, ((ASTNode) decl).getLength());
690
offset = code.indexOf("down }; // defines up and down"); //$NON-NLS-1$
691
decl = testF3(file, offset);
692
assertTrue(decl instanceof IASTName);
693
assertEquals("down", ((IASTName) decl).toString()); //$NON-NLS-1$
694
assertEquals(371, ((ASTNode) decl).getOffset());
695
assertEquals(4, ((ASTNode) decl).getLength());
697
offset = code.indexOf("N { int d; } // defines N and N::d"); //$NON-NLS-1$
698
decl = testF3(file, offset);
699
assertTrue(decl instanceof IASTName);
700
assertEquals("N", ((IASTName) decl).toString()); //$NON-NLS-1$
701
assertEquals(412, ((ASTNode) decl).getOffset());
702
assertEquals(1, ((ASTNode) decl).getLength());
704
offset = code.indexOf("d; } // defines N and N::d"); //$NON-NLS-1$
705
decl = testF3(file, offset);
706
assertTrue(decl instanceof IASTName);
707
assertEquals("d", ((IASTName) decl).toString()); //$NON-NLS-1$
708
assertEquals(695, ((ASTNode) decl).getOffset());
709
assertEquals(1, ((ASTNode) decl).getLength());
711
offset = code.indexOf("N1 = N; // defines N1"); //$NON-NLS-1$
712
decl = testF3(file, offset);
713
assertTrue(decl instanceof IASTName);
714
assertEquals("N1", ((IASTName) decl).toString()); //$NON-NLS-1$
715
assertEquals(457, ((ASTNode) decl).getOffset());
716
assertEquals(2, ((ASTNode) decl).getLength());
718
offset = code.indexOf("N; // defines N1"); //$NON-NLS-1$
719
def = testF3(file, offset);
720
assertTrue(def instanceof IASTName);
721
assertEquals("N", ((IASTName) def).toString()); //$NON-NLS-1$
722
assertEquals(412, ((ASTNode) def).getOffset());
723
assertEquals(1, ((ASTNode) def).getLength());
725
offset = code.indexOf("X anX; // defines anX"); //$NON-NLS-1$
726
def = testF3(file, offset);
727
assertTrue(def instanceof IASTName);
728
assertEquals("X", ((IASTName) def).toString()); //$NON-NLS-1$
729
assertEquals(177, ((ASTNode) def).getOffset());
730
assertEquals(1, ((ASTNode) def).getLength());
732
offset = code.indexOf("anX; // defines anX"); //$NON-NLS-1$
733
decl = testF3(file, offset);
734
assertTrue(decl instanceof IASTName);
735
assertEquals("X", ((IASTName) decl).toString()); //$NON-NLS-1$
736
assertEquals(code.indexOf("X()"), ((ASTNode) decl).getOffset());
737
assertEquals("X".length(), ((ASTNode) decl).getLength());
739
offset = code.indexOf("a; // declares a"); //$NON-NLS-1$
740
def = testF3(file, offset);
741
assertTrue(def instanceof IASTName);
742
assertEquals("a", ((IASTName) def).toString()); //$NON-NLS-1$
743
assertEquals(4, ((ASTNode) def).getOffset());
744
assertEquals(1, ((ASTNode) def).getLength());
746
offset = code.indexOf("c; // declares c"); //$NON-NLS-1$
747
def = testF3(file, offset);
748
assertTrue(def instanceof IASTName);
749
assertEquals("c", ((IASTName) def).toString()); //$NON-NLS-1$
750
assertEquals(37, ((ASTNode) def).getOffset());
751
assertEquals(1, ((ASTNode) def).getLength());
753
offset = code.indexOf("f(int y); // declar f"); //$NON-NLS-1$
754
def = testF3(file, offset);
755
assertTrue(def instanceof IASTName);
756
assertEquals("f", ((IASTName) def).toString()); //$NON-NLS-1$
757
assertEquals(61, ((ASTNode) def).getOffset());
758
assertEquals(1, ((ASTNode) def).getLength());
760
offset = code.indexOf("S; // declares S"); //$NON-NLS-1$
761
def = testF3(file, offset);
762
assertTrue(def instanceof IASTName);
763
assertEquals("S", ((IASTName) def).toString()); //$NON-NLS-1$
764
assertEquals(120, ((ASTNode) def).getOffset());
765
assertEquals(1, ((ASTNode) def).getLength());
767
offset = code.indexOf("Int; // declares Int"); //$NON-NLS-1$
768
decl = testF3(file, offset);
769
assertTrue(decl instanceof IASTName);
770
assertEquals("Int", ((IASTName) decl).toString()); //$NON-NLS-1$
771
assertEquals(625, ((ASTNode) decl).getOffset());
772
assertEquals(3, ((ASTNode) decl).getLength());
774
offset = code.indexOf("X anotherX; // declares anotherX"); //$NON-NLS-1$
775
def = testF3(file, offset);
776
assertTrue(def instanceof IASTName);
777
assertEquals("X", ((IASTName) def).toString()); //$NON-NLS-1$
778
assertEquals(177, ((ASTNode) def).getOffset());
779
assertEquals(1, ((ASTNode) def).getLength());
781
offset = code.indexOf("anotherX; // declares anotherX"); //$NON-NLS-1$
782
decl = testF3(file, offset);
783
assertTrue(decl instanceof IASTName);
784
assertEquals("anotherX", ((IASTName) decl).toString()); //$NON-NLS-1$
785
assertEquals(655, ((ASTNode) decl).getOffset());
786
assertEquals(8, ((ASTNode) decl).getLength());
788
offset = code.indexOf("N::d; // declares N::d"); //$NON-NLS-1$
789
def = testF3(file, offset);
790
assertTrue(def instanceof IASTName);
791
assertEquals("N", ((IASTName) def).toString()); //$NON-NLS-1$
792
assertEquals(412, ((ASTNode) def).getOffset());
793
assertEquals(1, ((ASTNode) def).getLength());
795
offset = code.indexOf("d; // declares N::d"); //$NON-NLS-1$
796
def = testF3(file, offset);
797
assertTrue(def instanceof IASTName);
798
assertEquals("d", ((IASTName) def).toString()); //$NON-NLS-1$
799
assertEquals(420, ((ASTNode) def).getOffset());
800
assertEquals(1, ((ASTNode) def).getLength());
803
public void testBug95225() throws Exception {
804
StringBuffer buffer = new StringBuffer();
805
buffer.append("class Overflow {\n"); //$NON-NLS-1$
806
buffer.append("public:\n"); //$NON-NLS-1$
807
buffer.append("Overflow(char,double,double);\n"); //$NON-NLS-1$
808
buffer.append("};\n"); //$NON-NLS-1$
809
buffer.append("void f(double x)\n"); //$NON-NLS-1$
810
buffer.append("{\n"); //$NON-NLS-1$
811
buffer.append("throw Overflow('+',x,3.45e107);\n"); //$NON-NLS-1$
812
buffer.append("}\n"); //$NON-NLS-1$
813
buffer.append("int foo() {\n"); //$NON-NLS-1$
814
buffer.append("try {\n"); //$NON-NLS-1$
815
buffer.append("f(1.2);\n"); //$NON-NLS-1$
816
buffer.append("}\n"); //$NON-NLS-1$
817
buffer.append("catch(Overflow& oo) {\n"); //$NON-NLS-1$
818
buffer.append(" // handle exceptions of type Overflow here\n"); //$NON-NLS-1$
819
buffer.append("}\n"); //$NON-NLS-1$
820
buffer.append("}\n"); //$NON-NLS-1$
822
String code = buffer.toString();
823
IFile file = importFile("testBug95225.cpp", code); //$NON-NLS-1$
825
int offset = code.indexOf("rflow('+',x,3.45e107);"); //$NON-NLS-1$
826
IASTNode decl = testF3(file, offset);
827
assertTrue(decl instanceof IASTName);
828
assertEquals("Overflow", ((IASTName) decl).toString()); //$NON-NLS-1$
829
assertEquals(25, ((ASTNode) decl).getOffset());
830
assertEquals(8, ((ASTNode) decl).getLength());
832
offset = code.indexOf("x,3.45e107);"); //$NON-NLS-1$
833
decl = testF3(file, offset);
834
assertTrue(decl instanceof IASTName);
835
assertEquals("x", ((IASTName) decl).toString()); //$NON-NLS-1$
836
assertEquals(72, ((ASTNode) decl).getOffset());
837
assertEquals(1, ((ASTNode) decl).getLength());
840
public void testNoDefinitions() throws Exception {
841
StringBuffer buffer = new StringBuffer();
842
buffer.append("extern int a1; // declares a\n"); //$NON-NLS-1$
843
buffer.append("extern const int c1; // declares c\n"); //$NON-NLS-1$
844
buffer.append("int f1(int); // declares f\n"); //$NON-NLS-1$
845
buffer.append("struct S1; // declares S\n"); //$NON-NLS-1$
846
buffer.append("typedef int Int; // declares Int\n"); //$NON-NLS-1$
848
String code = buffer.toString();
849
IFile file = importFile("testNoDefinitions.cpp", code); //$NON-NLS-1$
851
int offset = code.indexOf("a1; // declares a"); //$NON-NLS-1$
852
IASTNode decl = testF3(file, offset);
853
assertTrue(decl instanceof IASTName);
854
assertEquals("a1", ((IASTName) decl).toString()); //$NON-NLS-1$
855
assertEquals(11, ((ASTNode) decl).getOffset());
856
assertEquals(2, ((ASTNode) decl).getLength());
858
offset = code.indexOf("c1; // declares c"); //$NON-NLS-1$
859
decl = testF3(file, offset);
860
assertTrue(decl instanceof IASTName);
861
assertEquals("c1", ((IASTName) decl).toString()); //$NON-NLS-1$
862
assertEquals(46, ((ASTNode) decl).getOffset());
863
assertEquals(2, ((ASTNode) decl).getLength());
865
offset = code.indexOf("f1(int); // declares f"); //$NON-NLS-1$
866
decl = testF3(file, offset);
867
assertTrue(decl instanceof IASTName);
868
assertEquals("f1", ((IASTName) decl).toString()); //$NON-NLS-1$
869
assertEquals(68, ((ASTNode) decl).getOffset());
870
assertEquals(2, ((ASTNode) decl).getLength());
872
offset = code.indexOf("S1; // declares S"); //$NON-NLS-1$
873
decl = testF3(file, offset);
874
assertTrue(decl instanceof IASTName);
875
assertEquals("S1", ((IASTName) decl).toString()); //$NON-NLS-1$
876
assertEquals(98, ((ASTNode) decl).getOffset());
877
assertEquals(2, ((ASTNode) decl).getLength());
879
offset = code.indexOf("Int; // declares Int"); //$NON-NLS-1$
880
decl = testF3(file, offset);
881
assertTrue(decl instanceof IASTName);
882
assertEquals("Int", ((IASTName) decl).toString()); //$NON-NLS-1$
883
assertEquals(128, ((ASTNode) decl).getOffset());
884
assertEquals(3, ((ASTNode) decl).getLength());
887
public void testBug95202() throws Exception {
888
StringBuffer buffer = new StringBuffer();
889
buffer.append("struct A { }; // implicitlydeclared A::operator=\n"); //$NON-NLS-1$
890
buffer.append("struct B : A {\n"); //$NON-NLS-1$
891
buffer.append("B& operator=(const B &);\n"); //$NON-NLS-1$
892
buffer.append("};\n"); //$NON-NLS-1$
893
buffer.append("B& B::operator=(const B& s) {\n"); //$NON-NLS-1$
894
buffer.append("this->B::operator=(s); // wellformed\n"); //$NON-NLS-1$
895
buffer.append("return *this;\n"); //$NON-NLS-1$
896
buffer.append("}\n"); //$NON-NLS-1$
898
String code = buffer.toString();
899
IFile file = importFile("testBug95202.cpp", code); //$NON-NLS-1$
901
int offset = code.indexOf("s); // wellformed"); //$NON-NLS-1$
902
IASTNode decl = testF3(file, offset);
903
assertTrue(decl instanceof IASTName);
904
assertEquals("s", ((IASTName) decl).toString()); //$NON-NLS-1$
905
assertEquals(117, ((ASTNode) decl).getOffset());
906
assertEquals(1, ((ASTNode) decl).getLength());
909
public void testBug95229() throws Exception {
910
StringBuffer buffer = new StringBuffer();
911
buffer.append("struct A {\n"); //$NON-NLS-1$
912
buffer.append("operator short(); // F3 on operator causes an infinite loop\n"); //$NON-NLS-1$
913
buffer.append("} a;\n"); //$NON-NLS-1$
914
buffer.append("int f(int);\n"); //$NON-NLS-1$
915
buffer.append("int f(float);\n"); //$NON-NLS-1$
916
buffer.append("int i = f(a); // Calls f(int), because short -> int is\n"); //$NON-NLS-1$
918
String code = buffer.toString();
919
IFile file = importFile("testBug95229.cpp", code); //$NON-NLS-1$
921
int offset = code.indexOf("rator short(); // F3"); //$NON-NLS-1$
922
IASTNode decl = testF3(file, offset);
923
assertTrue(decl instanceof IASTName);
924
assertEquals("operator short int", ((IASTName) decl).toString()); //$NON-NLS-1$
925
assertEquals(11, ((ASTNode) decl).getOffset());
926
assertEquals(14, ((ASTNode) decl).getLength());
929
public void testBug78354() throws Exception {
930
StringBuffer buffer = new StringBuffer();
931
buffer.append("typedef int TestTypeOne;\n"); //$NON-NLS-1$
932
buffer.append("typedef int TestTypeTwo;\n"); //$NON-NLS-1$
933
buffer.append("int main()\n"); //$NON-NLS-1$
934
buffer.append("{\n"); //$NON-NLS-1$
935
buffer.append("TestTypeOne myFirstLink = 5;\n"); //$NON-NLS-1$
936
buffer.append("TestTypeTwo mySecondLink = 6;\n"); //$NON-NLS-1$
937
buffer.append("return 0;\n"); //$NON-NLS-1$
938
buffer.append("}\n"); //$NON-NLS-1$
940
String code = buffer.toString();
941
IFile file = importFileWithLink("testBug78354.cpp", code); //$NON-NLS-1$
943
int offset = code.indexOf("TestTypeOne myFirstLink = 5;"); //$NON-NLS-1$
944
IASTNode decl = testF3(file, offset);
945
assertTrue(decl instanceof IASTName);
946
assertEquals("TestTypeOne", ((IASTName) decl).toString()); //$NON-NLS-1$
947
assertEquals(12, ((ASTNode) decl).getOffset());
948
assertEquals(11, ((ASTNode) decl).getLength());
951
public void testBug103697() throws Exception {
952
StringBuffer buffer = new StringBuffer();
953
buffer.append("int x;\n"); //$NON-NLS-1$
954
buffer.append("int foo() {\n"); //$NON-NLS-1$
955
buffer.append(" return x;\n"); //$NON-NLS-1$
956
buffer.append("}\n"); //$NON-NLS-1$
958
String code = buffer.toString();
959
IFile file = importFileWithLink("testBug103697.cpp", code); //$NON-NLS-1$
961
int offset = code.indexOf("return x;\n") + "return ".length(); //$NON-NLS-1$ //$NON-NLS-2$
962
IASTNode decl = testF3(file, offset);
963
assertTrue(decl instanceof IASTName);
964
assertEquals("x", ((IASTName) decl).toString()); //$NON-NLS-1$
965
assertEquals(4, ((ASTNode) decl).getOffset());
966
assertEquals(1, ((ASTNode) decl).getLength());
969
public void testBug76043() throws Exception {
970
StringBuffer buffer = new StringBuffer();
971
buffer.append("int x;\n"); //$NON-NLS-1$
972
buffer.append("int foo() {\n"); //$NON-NLS-1$
973
buffer.append(" return x;\n"); //$NON-NLS-1$
974
buffer.append("}\n"); //$NON-NLS-1$
975
String code = buffer.toString();
977
IFile file = importFileInsideLinkedFolder("testBug76043.c", code, "folder"); //$NON-NLS-1$ //$NON-NLS-2$
979
assertFalse(file.isLinked()); // I'm not sure why the IResource#isLinked() returns false if it's contained within a linked folder
981
int offset = code.indexOf("return x;\n") + "return ".length(); //$NON-NLS-1$ //$NON-NLS-2$
982
IASTNode decl = testF3(file, offset);
983
assertTrue(decl instanceof IASTName);
984
assertEquals("x", ((IASTName) decl).toString()); //$NON-NLS-1$
985
assertEquals(4, ((ASTNode) decl).getOffset());
986
assertEquals(1, ((ASTNode) decl).getLength());
989
// typedef int (*functionPointer)(int);
990
// functionPointer fctVariable;
992
// typedef int (functionPointerArray[2])(int);
993
// functionPointerArray fctVariablArray;
994
public void testBug195822() throws Exception {
995
StringBuffer[] contents= getContentsForTest(2);
996
String code= contents[0].toString();
997
String appendCode= contents[1].toString();
999
String[] filenames= {"testBug195822.c", "testBug195822.cpp"};
1000
for (int i= 0; i < 2; i++) {
1001
IFile file = importFile(filenames[i], code);
1002
int od1 = code.indexOf("functionPointer");
1003
int or1 = code.indexOf("functionPointer", od1 + 1);
1005
IASTNode decl = testF3(file, or1);
1006
assertTrue(decl instanceof IASTName);
1007
assertEquals("functionPointer", ((IASTName) decl).toString()); //$NON-NLS-1$
1008
assertEquals(od1, ((ASTNode) decl).getOffset());
1010
IEditorPart editor= PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
1011
assertNotNull(editor);
1012
assertTrue(editor instanceof ITextEditor);
1013
IDocument doc= ((ITextEditor) editor).getDocumentProvider().getDocument(editor.getEditorInput());
1014
doc.replace(doc.getLength(), 0, appendCode);
1015
int od2 = appendCode.indexOf("functionPointerArray");
1016
int or2 = appendCode.indexOf("functionPointerArray", od2 + 1);
1018
decl = testF3(file, code.length() + or2);
1019
assertTrue(decl instanceof IASTName);
1020
assertEquals("functionPointerArray", ((IASTName) decl).toString());
1021
assertEquals(code.length() + od2, ((ASTNode) decl).getOffset());
1026
// EMPTY void foo() {}
1027
public void testEmptyMacro_Bug198649() throws Exception {
1028
String code= getContentsForTest(1)[0].toString();
1029
String[] filenames= {"testBug198649.c", "testBug198649.cpp"};
1030
for (int i= 0; i < 2; i++) {
1031
IFile file = importFile(filenames[i], code);
1032
int od1 = code.indexOf("EMPTY");
1033
int or1 = code.indexOf("EMPTY", od1 + 1);
1035
IASTNode decl = testF3(file, or1);
1036
assertTrue(decl instanceof IASTName);
1037
assertEquals("EMPTY", ((IASTName) decl).toString()); //$NON-NLS-1$
1038
assertEquals(od1, ((ASTNode) decl).getOffset());
1042
// static int myFunc(int) {}
1043
// #define USE_FUNC(x) (myFunc(x) == 0)
1044
public void testFallBackForStaticFuncs_Bug252549() throws Exception {
1045
String code= getContentsForTest(1)[0].toString();
1046
String[] filenames= {"testBug252549.c", "testBug252549.cpp"};
1047
for (int i= 0; i < 2; i++) {
1048
IFile file = importFile(filenames[i], code);
1049
int offset= code.indexOf("myFunc(x)");
1050
IASTNode decl= testF3(file, offset);
1051
assertTrue(decl instanceof IASTName);
1052
final IASTName name = (IASTName) decl;
1053
assertTrue(name.isDefinition());
1054
assertEquals("myFunc", name.toString());
1059
// void method(int p) {}
1062
// void test(A* a) {
1066
// void A::method(int a, int b) {}
1067
// void B::method(int b) {}
1068
public void testUnresolvedMethod_278337() throws Exception {
1069
String code= getContentsForTest(1)[0].toString();
1070
IFile file = importFile("testBug278337.cpp", code);
1071
IASTNode node= testF3(file, code.indexOf("method();"));
1072
assertContents(code, node.getFileLocation().getNodeOffset(), "method(int p)");
1073
node= testF3(file, code.indexOf("method(0);"));
1075
node= testF3(file, code.indexOf("method(int a, int b)"));
1076
assertContents(code, node.getFileLocation().getNodeOffset(), "method(int p)");
1077
node= testF3(file, code.indexOf("method(int b)"));
1078
// Should not navigate away since there is no good candidate.
1079
assertContents(code, node.getFileLocation().getNodeOffset(), "method(int b)");
1087
public void testUnresolvedType() throws Exception {
1088
String code= getContentsForTest(1)[0].toString();
1089
IFile file = importFile("testUndefinedType.cpp", code);
1090
int offset= code.indexOf("B b;");
1091
IASTNode node= testF3(file, offset);
1095
// void func(int a);
1096
// void func(float a);
1097
// void func(int* a);
1101
public void testUnresolvedOverloadedFunction() throws Exception {
1102
String code= getContentsForTest(1)[0].toString();
1103
IFile file = importFile("testUnresolvedOverloadFunction.cpp", code);
1104
int offset= code.indexOf("func();");
1106
IASTNode node= testF3(file, offset);
1107
fail("Didn't expect navigation to succeed due to multiple choices.");
1108
} catch (RuntimeException e) {
1109
assertEquals("ambiguous input: 3", e.getMessage());
1114
// template<typename T> void func(T a, T b){}
1116
// template<typename Tmp> void testFunc() {
1118
// nm::func(val, val);
1120
public void testDependentNameInNamespace_281736() throws Exception {
1121
String code= getContentsForTest(1)[0].toString();
1122
IFile file = importFile("testDependentNameInNamespace.cpp", code);
1123
int offset= code.indexOf("func(val, val);");
1124
IASTNode node= testF3(file, offset);
1125
assertContents(code, node.getFileLocation().getNodeOffset(), "func(T a, T b)");
1128
// template<typename T> void func(T a){}
1129
// template<typename T> void func(T a, T b){}
1131
// template<typename Tmp> void testFunc() {
1133
// func(val, val); // F3 could know that 'func(T a)' cannot be a correct match.
1135
public void testDependentNameTwoChoices_281736() throws Exception {
1136
String code= getContentsForTest(1)[0].toString();
1137
IFile file = importFile("testDependentNameTwoChoices_281736.cpp", code);
1138
int offset= code.indexOf("func(val, val);");
1139
IASTNode node= testF3(file, offset);
1140
assertContents(code, node.getFileLocation().getNodeOffset(), "func(T a, T b)");
1144
// template <typename T> class AAA { T _t; };
1147
public void testBug92632() throws Exception {
1148
String code= getContentsForTest(1)[0].toString();
1149
IFile file = importFile("testBug92632.cpp", code);
1150
int index = code.indexOf("AAA<int>"); //$NON-NLS-1$
1151
IASTNode node= testF3(file, index);
1152
assertContents(code, node.getFileLocation().getNodeOffset(), "AAA");
1153
node= testF3(file, index+4);
1154
assertContents(code, node.getFileLocation().getNodeOffset(), "AAA");
1157
// void bug(int var) {
1161
public void testBug325135a() throws Exception {
1162
String code = getAboveComment();
1163
IFile file = importFile("testBug325135a.cpp", code); //$NON-NLS-1$
1164
int parOffset= code.indexOf("var)");
1166
int offset = code.indexOf("var;"); //$NON-NLS-1$
1167
IASTNode decl = testF3(file, offset);
1168
assertTrue(decl instanceof IASTName);
1169
assertEquals("var", ((IASTName) decl).toString()); //$NON-NLS-1$
1170
assertEquals(parOffset, ((ASTNode) decl).getOffset());
1171
assertEquals(3, ((ASTNode) decl).getLength());
1173
offset = code.indexOf("var);"); //$NON-NLS-1$
1174
decl = testF3(file, offset);
1175
assertTrue(decl instanceof IASTName);
1176
assertEquals("var", ((IASTName) decl).toString()); //$NON-NLS-1$
1177
assertEquals(parOffset, ((ASTNode) decl).getOffset());
1178
assertEquals(3, ((ASTNode) decl).getLength());
1181
// template<typename T> class C {
1182
// template<typename V> void f(V v) {
1187
public void testBug325135b() throws Exception {
1188
String code = getAboveComment();
1189
IFile file = importFile("testBug325135b.cpp", code); //$NON-NLS-1$
1191
int offsetT= code.indexOf("T>");
1192
int offsetV= code.indexOf("V>");
1194
int offset = code.indexOf("T t;");
1195
IASTNode decl = testF3(file, offset);
1196
assertTrue(decl instanceof IASTName);
1197
assertEquals("T", ((IASTName) decl).toString());
1198
assertEquals(offsetT, ((ASTNode) decl).getOffset());
1200
offset = code.indexOf("V s;");
1201
decl = testF3(file, offset);
1202
assertTrue(decl instanceof IASTName);
1203
assertEquals("V", ((IASTName) decl).toString());
1204
assertEquals(offsetV, ((ASTNode) decl).getOffset());