/*******************************************************************************
 * Copyright (c) 2006, 2015 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.ui.tests.text.selection;

import java.io.IOException;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.IPDOMManager;
import org.eclipse.cdt.core.dom.ast.IASTFileLocation;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTNameOwner;
import org.eclipse.cdt.core.dom.ast.IASTNode;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.dom.ast.IMacroBinding;
import org.eclipse.cdt.core.index.IIndex;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.core.testplugin.CProjectHelper;
import org.eclipse.cdt.core.testplugin.util.TestSourceReader;
import org.eclipse.cdt.internal.core.dom.parser.ASTNode;
import org.eclipse.cdt.ui.testplugin.CTestPlugin;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.FileEditorInput;

import junit.framework.Test;

/**
 * Test Ctrl-F3/F3 with the DOM Indexer for a C++ project.
 */
public class CPPSelectionIndexerTests extends BaseSelectionTestsIndexer {
	protected String sourceIndexerID;
	protected IIndex index;

	public CPPSelectionIndexerTests(String name) {
		super(name);
		sourceIndexerID = IPDOMManager.ID_FAST_INDEXER;
	}

	public static Test suite() {
		return suite(CPPSelectionIndexerTests.class);
	}

	@Override
	protected void setUp() throws Exception {
		super.setUp();

		// Create temp project
		fCProject = createProject("CPPSelectionTestsDOMIndexerProject");
		assertNotNull("Unable to create project", fCProject);
		//		MakeProjectNature.addNature(project, new NullProgressMonitor());
		//		ScannerConfigNature.addScannerConfigNature(project);
		//		PerProjectSICollector.calculateCompilerBuiltins(project);

		CCorePlugin.getIndexManager().setIndexerId(fCProject, sourceIndexerID);
		index = CCorePlugin.getIndexManager().getIndex(fCProject);
	}

	@Override
	protected void tearDown() throws Exception {
		closeAllEditors();
		CProjectHelper.delete(fCProject);
		super.tearDown();
	}

	private ICProject createProject(String projectName) throws CoreException {
		ICProject cPrj = CProjectHelper.createCCProject(projectName, "bin", IPDOMManager.ID_NO_INDEXER);
		return cPrj;
	}

	protected StringBuilder[] getContents(int sections) throws IOException {
		return TestSourceReader.getContentsForTest(CTestPlugin.getDefault().getBundle(), "ui",
				CPPSelectionIndexerTests.class, getName(), sections);
	}

	private void assertNode(String name, int offset, IASTNode node) {
		assertNotNull(node);
		assertEquals(node.toString(), name);
		IASTFileLocation loc = node.getFileLocation();
		assertEquals(loc.getNodeOffset(), offset);
		assertEquals(loc.getNodeLength(), name.length());
	}

	// // header
	// class Point{
	//  public:
	//     Point(): xCoord(0){}
	//     Point& operator=(const Point &rhs){return *this;}
	//     void* operator new [ ] (unsigned int);
	//  private:
	//     int xCoord;
	//  };

	// // source
	// #include "test93281.h"
	// static const Point zero;
	// int main(int argc, char **argv) {
	//    Point *p2 = new Point();
	//    p2->    operator // /* operator */ // F3 in the middle
	//    // of "operator" should work
	//    // \
	//    /* */
	//    =(zero);           // line B
	//    p2->operator /* oh yeah */ new // F3 in the middle of "operator"
	//    // should work
	//    //
	//    [ /* sweet */ ] //
	//    (2);
	//    return (0);
	// }
	public void testBug93281() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("test93281.h", hcode);
		IFile file = importFile("test93281.cpp", scode);
		waitUntilFileIsIndexed(index, file);

		int offset = scode.indexOf("p2->operator") + 6;
		IASTNode node = testF3(file, offset);

		assertTrue(node instanceof IASTName);
		assertEquals(((IASTName) node).toString(), "operator new[]");
		assertEquals(((ASTNode) node).getOffset(), hcode.indexOf("operator new"));
		assertEquals(((ASTNode) node).getLength(), 16);

		offset = scode.indexOf("p2->    operator") + 11;
		node = testF3(file, offset);

		assertTrue(node instanceof IASTName);
		assertEquals(((IASTName) node).toString(), "operator =");
		assertEquals(((ASTNode) node).getOffset(), hcode.indexOf("operator="));
		assertEquals(((ASTNode) node).getLength(), 9);
	}

	//	template <class T>
	//	inline void testTemplate(T& aRef);
	//
	//	class Temp {
	//	};

	//	#include <stdio.h>
	//	#include <stdlib.h>
	//	#include "test.h"
	//	int main(void) {
	//	        puts("Hello World!!!");
	//
	//	        Temp testFile;
	//	        testTemplate(testFile);
	//
	//	        return EXIT_SUCCESS;
	//	}
	public void testBug207320() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("test.h", hcode);
		IFile file = importFile("test.cpp", scode);
		waitUntilFileIsIndexed(index, file);

		int hoffset = hcode.indexOf("testTemplate");
		int soffset = scode.indexOf("testTemplate");
		IASTNode def = testF3(file, soffset + 2);
		assertTrue(def instanceof IASTName);
		assertEquals("testTemplate", ((IASTName) def).toString());
		assertEquals(hoffset, ((ASTNode) def).getOffset());
		assertEquals(12, ((ASTNode) def).getLength());
	}

	// template<typename T>
	// class C {
	//   public: void assign(const T* s) {}
	// };

	// #include "testTemplateClassMethod.h"
	// void main() {
	//   C<char> a;
	//   a.assign("aaa");
	// }
	public void testTemplateClassMethod_207320() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testTemplateClassMethod.h", hcode);
		IFile file = importFile("testTemplateClassMethod.cpp", scode);
		waitUntilFileIsIndexed(index, file);

		int hoffset = hcode.indexOf("assign");
		int soffset = scode.indexOf("assign");
		IASTNode def = testF3(file, soffset + 2);
		assertTrue(def instanceof IASTName);
		assertEquals("assign", ((IASTName) def).toString());
		assertEquals(hoffset, ((ASTNode) def).getOffset());
		assertEquals(6, ((ASTNode) def).getLength());
	}

	// // the header
	// extern int MyInt;       // MyInt is in another file
	// extern const int MyConst;   // MyConst is in another file
	// void MyFunc(int);       // often used in header files
	// typedef int NewInt;     // a normal typedef statement
	// struct MyStruct { int Member1; int Member2; };
	// class MyClass { int MemberVar; };

	// #include "basicDefinition.h"
	// int MyInt;
	// extern const int MyConst = 42;
	// void MyFunc(int a) { cout << a << endl; }
	// class MyClass;
	// struct MyStruct;
	public void testBasicDefinition() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("basicDefinition.h", hcode);
		IFile file = importFile("testBasicDefinition.cpp", scode);
		waitUntilFileIsIndexed(index, file);

		int hoffset = hcode.indexOf("MyInt");
		int soffset = scode.indexOf("MyInt");
		IASTNode decl = testF3(file, soffset + 2);
		IASTNode def = testF3(hfile, hoffset + 2);
		assertTrue(def instanceof IASTName);
		assertTrue(decl instanceof IASTName);
		assertEquals("MyInt", ((IASTName) decl).toString());
		assertEquals(hoffset, ((ASTNode) decl).getOffset());
		assertEquals(5, ((ASTNode) decl).getLength());
		assertEquals("MyInt", ((IASTName) def).toString());
		assertEquals(soffset, def.getFileLocation().getNodeOffset());
		assertEquals(5, ((ASTNode) def).getLength());

		hoffset = hcode.indexOf("MyConst");
		soffset = scode.indexOf("MyConst");
		decl = testF3(file, soffset + 2);
		def = testF3(hfile, hoffset + 2);
		assertTrue(def instanceof IASTName);
		assertTrue(decl instanceof IASTName);
		assertEquals("MyConst", ((IASTName) decl).toString());
		assertEquals(hoffset, ((ASTNode) decl).getOffset());
		assertEquals(7, ((ASTNode) decl).getLength());
		assertEquals("MyConst", ((IASTName) def).toString());
		assertEquals(soffset, def.getFileLocation().getNodeOffset());
		assertEquals(7, ((ASTNode) def).getLength());

		hoffset = hcode.indexOf("MyFunc");
		soffset = scode.indexOf("MyFunc");
		decl = testF3(file, soffset + 2);
		def = testF3(hfile, hoffset + 2);
		assertTrue(def instanceof IASTName);
		assertTrue(decl instanceof IASTName);
		assertEquals("MyFunc", ((IASTName) decl).toString());
		assertEquals(hoffset, ((ASTNode) decl).getOffset());
		assertEquals(6, ((ASTNode) decl).getLength());
		assertEquals("MyFunc", ((IASTName) def).toString());
		assertEquals(soffset, def.getFileLocation().getNodeOffset());
		assertEquals(6, ((ASTNode) def).getLength());

		hoffset = hcode.indexOf("MyStruct");
		soffset = scode.indexOf("MyStruct");
		decl = testF3(file, soffset + 2);
		def = testF3(hfile, hoffset + 2);
		assertTrue(def instanceof IASTName);
		assertTrue(decl instanceof IASTName);
		assertEquals("MyStruct", ((IASTName) decl).toString());
		assertEquals(hoffset, ((ASTNode) decl).getOffset());
		assertEquals(8, ((ASTNode) decl).getLength());
		assertEquals("MyStruct", ((IASTName) def).toString());
		assertEquals(hoffset, def.getFileLocation().getNodeOffset());
		assertEquals(8, ((ASTNode) def).getLength());

		hoffset = hcode.indexOf("MyClass");
		soffset = scode.indexOf("MyClass");
		decl = testF3(file, soffset + 2);
		def = testF3(hfile, hoffset + 2);
		assertTrue(def instanceof IASTName);
		assertTrue(decl instanceof IASTName);
		assertEquals("MyClass", ((IASTName) decl).toString());
		assertEquals(hoffset, ((ASTNode) decl).getOffset());
		assertEquals(7, ((ASTNode) decl).getLength());
		assertEquals("MyClass", ((IASTName) def).toString());
		assertEquals(hoffset, def.getFileLocation().getNodeOffset());
		assertEquals(7, ((ASTNode) def).getLength());
	}

	// // the header
	// namespace N {
	//    template < class T > class AAA { T _t; };
	// };

	// #include "testBasicTemplateInstance.h"
	// N::AAA<int> a;
	public void testBasicTemplateInstance_207320() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testBasicTemplateInstance.h", hcode);
		IFile file = importFile("testBasicTemplateInstance.cpp", scode);
		waitUntilFileIsIndexed(index, file);

		int hoffset = hcode.indexOf("AAA");
		int soffset = scode.indexOf("AAA<int>");
		IASTNode decl1 = testF3(file, soffset, 3);
		assertTrue(decl1 instanceof IASTName);
		assertEquals("AAA", ((IASTName) decl1).toString());
		assertEquals(hoffset, decl1.getFileLocation().getNodeOffset());
		assertEquals(3, ((ASTNode) decl1).getLength());

		IASTNode decl2 = testF3(file, soffset, 8);
		assertEquals("AAA", ((IASTName) decl2).toString());
		assertEquals(hoffset, decl2.getFileLocation().getNodeOffset());
		assertEquals(3, ((ASTNode) decl2).getLength());
	}

	// // the header
	// class X {
	// public:
	//    X(int); // openReferences fails to find the constructor in g()
	// };

	// #include "testBug86829A.h"
	// X f(X);
	// void g()
	// {
	//    X b = f(X(2)); // openDeclarations on X(int) shall find constructor
	// }
	public void testBug86829A() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testBug86829A.h", hcode);
		IFile file = importFile("testBug86829A.cpp", scode);
		waitUntilFileIsIndexed(index, file);

		int offset = scode.indexOf("X(2)");
		int doffset = hcode.indexOf("X(int)");
		IASTNode decl = testF3(file, offset);
		assertTrue(decl instanceof IASTName);
		assertEquals("X", ((IASTName) decl).toString());
		assertEquals(doffset, decl.getFileLocation().getNodeOffset());
		assertEquals(1, ((ASTNode) decl).getLength());
	}

	// // the header
	// class X {
	// public:
	//    operator int();
	// };
	// class Y {
	// public:
	//    operator X();
	// };

	// #include "testBug86829B.h"
	// void testfunc() {
	// Y a;
	// int c = X(a); // OK: a.operator X().operator int()
	// }
	public void _testBug86829B() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testBug86829B.h", hcode);
		IFile file = importFile("testBug86829B.cpp", scode);
		waitUntilFileIsIndexed(index, file);

		int offset = scode.indexOf("X(a)");
		int doffset = hcode.indexOf("X()");
		IASTNode decl = testF3(file, offset);
		assertTrue(decl instanceof IASTName);
		assertEquals(decl.toString(), "X");
		assertEquals(doffset, decl.getFileLocation().getNodeOffset());
		assertEquals(1, ((ASTNode) decl).getLength());
	}

	// // the header
	// extern int a; 				// declares
	// extern const int c = 1; 		// defines
	// struct S {int a; int b;}; 	// defines
	// struct X { 					// defines
	//    int x; 					// defines nonstatic data member
	//    static int y; 			// declares static data member
	//    X(): x(0) { } 			// defines a constructor of
	// };
	// enum E {up, down}; 			// defines
	// namespace N {int d;} 		// defines
	// namespace N1 = N; 			// defines
	// int f(int);  				// declares
	// extern X anotherX; 			// declares

	// #include "testCPPSpecDeclsDefs.h"
	// int a; 						// defines
	// int X::y = 1; 				// defines
	// X anX; 						// defines variable, implicitly calls ctor
	// extern const int c; 			// declares
	// int f(int x) {return x+a;}   // defines
	// struct S; 					// declares
	// typedef int Int; 			// declares
	// using N::d; 					// declares
	// S s;
	// Int lhs= s.a+s.b+up+down+anX+0;
	public void testCPPSpecDeclsDefs() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testCPPSpecDeclsDefs.h", hcode);
		IFile file = importFile("testCPPSpecDeclsDefs.cpp", scode);
		waitUntilFileIsIndexed(index, file);

		int offset0 = hcode.indexOf("a;");
		int offset1 = scode.indexOf("a;");
		IASTNode decl = testF3(hfile, offset0);
		assertNode("a", offset1, decl);
		decl = testF3(file, offset1);
		assertNode("a", offset0, decl);

		offset0 = hcode.indexOf("int c") + 4;
		offset1 = scode.indexOf("int c") + 4;
		decl = testF3(hfile, offset0);
		assertNode("c", offset1, decl);
		decl = testF3(file, offset1);
		assertNode("c", offset0, decl);

		offset0 = hcode.indexOf("f(int");
		offset1 = scode.indexOf("f(int");
		decl = testF3(hfile, offset0);
		assertNode("f", offset1, decl);
		decl = testF3(file, offset1);
		assertNode("f", offset0, decl);

		offset0 = scode.indexOf("x)");
		decl = testF3(file, offset0);
		assertNode("x", offset0, decl);

		offset1 = scode.indexOf("x+a");
		decl = testF3(file, offset1);
		assertNode("x", offset0, decl);

		offset0 = scode.indexOf("a;");
		offset1 = scode.indexOf("a;}");
		decl = testF3(file, offset1);
		assertNode("a", offset0, decl);

		offset0 = hcode.indexOf("S");
		offset1 = scode.indexOf("S;");
		int offset2 = scode.indexOf("S", offset1);
		decl = testF3(hfile, offset0);
		assertNode("S", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("S", offset0, decl);
		decl = testF3(file, offset2);
		assertNode("S", offset0, decl);

		offset0 = hcode.indexOf("a; int b;};");
		offset1 = scode.indexOf("a+s.b");
		decl = testF3(hfile, offset0);
		assertNode("a", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("a", offset0, decl);

		offset0 = hcode.indexOf("b;};");
		offset1 = scode.indexOf("s.b") + 2;
		decl = testF3(hfile, offset0);
		assertNode("b", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("b", offset0, decl);

		offset0 = hcode.indexOf("X");
		offset1 = scode.indexOf("X");
		offset2 = scode.indexOf("X", offset1 + 1);
		decl = testF3(hfile, offset0);
		assertNode("X", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("X", offset0, decl);
		decl = testF3(file, offset2);
		assertNode("X", offset0, decl);

		offset0 = hcode.indexOf("x;");
		offset1 = hcode.indexOf("x", offset0 + 1);
		decl = testF3(hfile, offset0);
		assertNode("x", offset0, decl);
		decl = testF3(hfile, offset1);
		assertNode("x", offset0, decl);

		offset0 = hcode.indexOf("y;");
		offset1 = scode.indexOf("y");
		decl = testF3(hfile, offset0);
		assertNode("y", offset1, decl);
		decl = testF3(file, offset1);
		assertNode("y", offset0, decl);

		offset0 = hcode.indexOf("X()");
		decl = testF3(hfile, offset0);
		assertNode("X", offset0, decl);

		offset0 = hcode.indexOf("up");
		offset1 = scode.indexOf("up");
		decl = testF3(hfile, offset0);
		assertNode("up", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("up", offset0, decl);

		offset0 = hcode.indexOf("down");
		offset1 = scode.indexOf("down");
		decl = testF3(hfile, offset0);
		assertNode("down", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("down", offset0, decl);

		offset0 = hcode.indexOf("N");
		offset1 = hcode.indexOf("N;", offset0 + 1);
		offset2 = scode.indexOf("N");
		decl = testF3(hfile, offset0);
		assertNode("N", offset0, decl);
		decl = testF3(hfile, offset1);
		assertNode("N", offset0, decl);
		decl = testF3(file, offset2);
		assertNode("N", offset0, decl);

		offset0 = hcode.indexOf("d;");
		offset1 = scode.indexOf("d;");
		decl = testF3(hfile, offset0);
		assertNode("d", offset0, decl);
		// 	    does not work, created separate testcase
		//        decl= testF3(file, offset1);
		//        assertNode("d", offset0, decl);

		offset0 = hcode.indexOf("N1");
		decl = testF3(hfile, offset0);
		assertNode("N1", offset0, decl);

		offset0 = scode.indexOf("anX");
		offset1 = scode.indexOf("anX", offset0 + 1);
		decl = testF3(file, offset0);
		assertNode("X", hcode.indexOf("X()"), decl);
		decl = testF3(file, offset1);
		assertNode("anX", offset0, decl);

		offset0 = scode.indexOf("Int");
		offset1 = scode.indexOf("Int", offset0 + 1);
		decl = testF3(file, offset0);
		assertNode("Int", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("Int", offset0, decl);
	}

	// // the header
	// namespace N {int d;} 		// defines

	// #include "testBug168533.h"
	// using N::d; 					// declares
	// int a= d;
	public void testBug168533() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testBug168533.h", hcode);
		IFile file = importFile("testBug168533.cpp", scode);
		waitUntilFileIsIndexed(index, file);

		int offset0 = hcode.indexOf("d;");
		int offset1 = scode.indexOf("d;");
		int offset2 = scode.indexOf("d", offset1);
		IASTNode decl = testF3(hfile, offset0);
		assertNode("d", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("d", offset0, decl);
		decl = testF3(file, offset2);
		assertNode("d", offset0, decl);
	}

	// class Overflow {
	// public:
	//    Overflow(char,double,double);
	// };

	// #include "testBug95225.h"
	// void f(double x) {
	//    throw Overflow('+',x,3.45e107);
	// }
	// int foo() {
	//    try {
	//       f(1.2);
	//    }
	//    catch(Overflow& oo) {
	// 				// handle exceptions of type Overflow here
	//    }
	// }
	public void testBug95225() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testBug95225.h", hcode);
		IFile file = importFile("testBug95225.cpp", scode);
		waitUntilFileIsIndexed(index, file);
		IASTNode decl;
		int offset0, offset1;

		offset0 = hcode.indexOf("Overflow");
		offset1 = scode.indexOf("rflow&");
		decl = testF3(file, offset1);
		assertNode("Overflow", offset0, decl);
		decl = testF3(hfile, offset0);
		assertNode("Overflow", offset0, decl);

		offset0 = hcode.indexOf("Overflow(");
		offset1 = scode.indexOf("rflow('+'");
		decl = testF3(file, offset1);
		assertNode("Overflow", offset0, decl);
		decl = testF3(hfile, offset0);
		assertNode("Overflow", offset0, decl);

		offset0 = scode.indexOf("x");
		offset1 = scode.indexOf("x", offset0);
		decl = testF3(file, offset0);
		assertNode("x", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("x", offset0, decl);
	}

	// struct A { }; // implicitly declared A::operator=
	// struct B : A {
	//    B& operator=(const B &);
	// };

	// #include "testBug95202.h"
	// B& B::operator=(const B& s) {
	//    this->B::operator=(s); // wellformed
	//    return *this;
	// }
	public void testBug95202() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testBug95202.h", hcode);
		IFile file = importFile("testBug95202.cpp", scode);
		waitUntilFileIsIndexed(index, file);
		IASTNode decl;
		int offset0, offset1;

		offset0 = scode.indexOf("s)");
		offset1 = scode.indexOf("s);", offset0 + 1);
		decl = testF3(file, offset0);
		assertNode("s", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("s", offset0, decl);
	}

	// extern int abc;

	// #include "testBug101287.h"
	// int main(int argc, char **argv) {
	//    abc;
	// }
	public void testBug101287() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testBug101287.h", hcode);
		IFile file = importFile("testBug101287.cpp", scode);
		waitUntilFileIsIndexed(index, file);
		IASTNode decl;
		int offset0, offset1;

		offset0 = hcode.indexOf("abc");
		offset1 = scode.indexOf("abc");
		decl = testF3(hfile, offset0);
		assertNode("abc", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("abc", offset0, decl);
	}

	// struct RTBindingEnd
	// {
	//    int index;
	// };

	// #include "testBug102258.h"
	// void f(RTBindingEnd & end) {
	// }
	public void testBug102258() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testBug102258.h", hcode);
		IFile file = importFile("testBug102258.cpp", scode);
		waitUntilFileIsIndexed(index, file);
		IASTNode decl;
		int offset0, offset1;

		offset0 = hcode.indexOf("RTBindingEnd");
		offset1 = scode.indexOf("RTBindingEnd");
		decl = testF3(hfile, offset0);
		assertNode("RTBindingEnd", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("RTBindingEnd", offset0, decl);
	}

	// namespace foo {
	//    int g() {
	//       return 0;
	//    }
	// }

	// #include "testBug103323.h"
	// int f() {
	//    return foo::g();
	// }
	public void testBug103323() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testBug103323.h", hcode);
		IFile file = importFile("testBug103323.cpp", scode);
		waitUntilFileIsIndexed(index, file);
		IASTNode decl;
		int offset0, offset1;

		offset0 = hcode.indexOf("g()");
		offset1 = scode.indexOf("g()");
		decl = testF3(hfile, offset0);
		assertNode("g", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("g", offset0, decl);

		testSimple_Ctrl_G_Selection(file, offset1, 1, 1);
	}

	// typedef int TestTypeOne;
	// typedef int TestTypeTwo;

	// #include "testBug78354.h"
	// int main()
	// {
	//    TestTypeOne myFirstLink = 5;
	//    TestTypeTwo mySecondLink = 6;
	//    return 0;
	// }
	public void testBug78354() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testBug78354.h", hcode);
		IFile file = importFile("testBug78354.cpp", scode);
		waitUntilFileIsIndexed(index, file);
		IASTNode decl;
		int offset0, offset1;

		offset0 = hcode.indexOf("TestTypeOne");
		offset1 = scode.indexOf("TestTypeOne");
		decl = testF3(hfile, offset0);
		assertNode("TestTypeOne", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("TestTypeOne", offset0, decl);

		offset0 = hcode.indexOf("TestTypeTwo");
		offset1 = scode.indexOf("TestTypeTwo");
		decl = testF3(hfile, offset0);
		assertNode("TestTypeTwo", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("TestTypeTwo", offset0, decl);
	}

	// int x;

	// #include "testBug103697.h"
	// int foo() {
	//     return x;
	// }
	public void testBug103697() throws Exception {
		if (System.getProperty("cdt.skip.known.test.failures") == null) {
			return;
		}
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFileWithLink("testBug103697.h", hcode);
		IFile file = importFileWithLink("testBug103697.cpp", scode);
		waitUntilFileIsIndexed(index, file);
		IASTNode decl;
		int offset0, offset1;

		offset0 = hcode.indexOf("x");
		offset1 = scode.indexOf("x");
		decl = testF3(hfile, offset0);
		assertNode("x", offset0, decl);
		decl = testF3(file, offset1);
		assertNode("x", offset0, decl);
	}

	// class __attribute__((visibility("default"))) FooClass
	// {
	//    int foo();
	// };

	// #include "testBug108202.h"
	// int FooClass::foo() {
	//    return 0;
	// }
	public void testBug108202() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testBug108202.h", hcode);
		IFile file = importFile("testBug108202.cpp", scode);
		waitUntilFileIsIndexed(index, file);
		IASTNode decl;
		int offset0, offset1;

		offset0 = hcode.indexOf("foo");
		offset1 = scode.indexOf("foo");
		decl = testF3(hfile, offset0);
		assertNode("foo", offset1, decl);
		decl = testF3(file, offset1);
		assertNode("foo", offset0, decl);
	}

	// void c();

	// #include "c.h"
	// void c() {}

	// void cpp();

	// #include "cpp.h"
	// void cpp() {}
	public void testCNavigationInCppProject_bug183973() throws Exception {
		StringBuilder[] buffers = getContents(4);
		String hccode = buffers[0].toString();
		String ccode = buffers[1].toString();
		String hcppcode = buffers[2].toString();
		String cppcode = buffers[3].toString();
		IFile hcfile = importFile("c.h", hccode);
		IFile cfile = importFile("c.c", ccode);
		IFile hcppfile = importFile("cpp.h", hcppcode);
		IFile cppfile = importFile("cpp.cpp", cppcode);
		CCorePlugin.getIndexManager().reindex(fCProject);
		waitForIndexer(fCProject);

		IASTNode decl;
		int offset0, offset1;
		// cpp navigation
		offset0 = hcppcode.indexOf("cpp(");
		offset1 = cppcode.indexOf("cpp(");
		decl = testF3(hcppfile, offset0);
		assertNode("cpp", offset1, decl);
		decl = testF3(cppfile, offset1);
		assertNode("cpp", offset0, decl);

		// plain-c navigation
		offset0 = hccode.indexOf("c(");
		offset1 = ccode.indexOf("c(");
		decl = testF3(hcfile, offset0);
		assertNode("c", offset1, decl);
		decl = testF3(cfile, offset1);
		assertNode("c", offset0, decl);
	}

	// typedef struct {
	//    int a;
	// } usertype;
	// void func(usertype t);

	// #include "testBug190730.h"
	// void func(usertype t) {
	// }
	public void testFuncWithTypedefForAnonymousStruct_190730() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testBug190730.h", hcode);
		IFile file = importFile("testBug190730.cpp", scode);
		waitUntilFileIsIndexed(index, file);
		IASTNode decl;
		int offset0, offset1;

		offset0 = hcode.indexOf("func");
		offset1 = scode.indexOf("func");
		decl = testF3(hfile, offset0);
		assertNode("func", offset1, decl);
		decl = testF3(file, offset1);
		assertNode("func", offset0, decl);
	}

	// typedef enum {
	//    int eitem
	// } userEnum;
	// void func(userEnum t);

	// #include "testBug190730_2.h"
	// void func(userEnum t) {
	// }
	public void testFuncWithTypedefForAnonymousEnum_190730() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testBug190730_2.h", hcode);
		IFile file = importFile("testBug190730_2.cpp", scode);
		waitUntilFileIsIndexed(index, file);
		IASTNode decl;
		int offset0, offset1;

		offset0 = hcode.indexOf("func");
		offset1 = scode.indexOf("func");
		decl = testF3(hfile, offset0);
		assertNode("func", offset1, decl);
		decl = testF3(file, offset1);
		assertNode("func", offset0, decl);
	}

	//    #define MY_MACRO 0xDEADBEEF
	//    #define MY_FUNC() 00
	//    #define MY_PAR( aRef );

	//  #include "macrodef.h"
	//	int basictest(void){
	//	   int tester = MY_MACRO;  //OK: F3 works
	//	   int xx= MY_FUNC();
	//     MY_PAR(0);
	//  }
	public void testMacroNavigation() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("macrodef.h", hcode);
		IFile file = importFile("macronavi.cpp", scode);
		waitUntilFileIsIndexed(index, file);
		IASTNode decl;
		int offset0, offset1;

		offset0 = hcode.indexOf("MY_MACRO");
		offset1 = scode.indexOf("MY_MACRO");
		decl = testF3(file, offset1);
		assertNode("MY_MACRO", offset0, decl);

		offset0 = hcode.indexOf("MY_FUNC");
		offset1 = scode.indexOf("MY_FUNC");
		decl = testF3(file, offset1);
		assertNode("MY_FUNC", offset0, decl);

		offset0 = hcode.indexOf("MY_PAR");
		offset1 = scode.indexOf("MY_PAR");
		decl = testF3(file, offset1);
		assertNode("MY_PAR", offset0, decl);
	}

	//  #define MY_MACRO 0xDEADBEEF
	//  #define MY_PAR( aRef ) aRef;
	//  int gvar;

	//  #include "macrodef.h"
	//	int basictest(void){
	//	   int tester = MY_PAR(MY_MACRO);
	//     tester= MY_PAR(gvar);
	//  }
	public void testMacroNavigation_Bug208300() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("macrodef.h", hcode);
		IFile file = importFile("macronavi.cpp", scode);
		waitUntilFileIsIndexed(index, file);
		IASTNode decl;
		int offset0, offset1;

		offset0 = hcode.indexOf("MY_PAR");
		offset1 = scode.indexOf("MY_PAR");
		decl = testF3(file, offset1);
		assertNode("MY_PAR", offset0, decl);

		offset0 = hcode.indexOf("MY_MACRO");
		offset1 = scode.indexOf("MY_MACRO");
		decl = testF3(file, offset1);
		assertNode("MY_MACRO", offset0, decl);

		offset0 = hcode.indexOf("gvar");
		offset1 = scode.indexOf("gvar");
		decl = testF3(file, offset1);
		assertNode("gvar", offset0, decl);
	}

	//	#define MYMACRO

	//	#undef MYMACRO
	public void testUndef_312399() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testUndef_312399.h", hcode);
		IFile file = importFile("testUndef_312399.cpp", scode);
		waitUntilFileIsIndexed(index, file);

		IASTNode target = testF3(file, scode.indexOf("MYMACRO"));
		assertTrue(target instanceof IASTName);
		assertEquals("MYMACRO", ((IASTName) target).toString());
		assertEquals(hcode.indexOf("MYMACRO"), target.getFileLocation().getNodeOffset());
		assertEquals("MYMACRO".length(), ((ASTNode) target).getLength());
	}

	//  int wurscht;

	//  #include "aheader.h"
	public void testIncludeNavigation() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("aheader.h", hcode);
		IFile file = importFile("includenavi.cpp", scode);
		waitUntilFileIsIndexed(index, file);
		IASTNode decl;
		int offset0, offset1;

		offset1 = scode.indexOf("aheader.h");
		testF3(file, offset1);
		IEditorPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
		IEditorInput input = part.getEditorInput();
		assertEquals("aheader.h", ((FileEditorInput) input).getFile().getName());
	}

	// void cfunc();
	// void cxcpp() {
	//    cfunc();
	// }

	// extern "C" void cxcpp();
	// void cppfunc() {
	//    cxcpp();
	// }
	public void testNavigationCppCallsC() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String ccode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile cfile = importFile("s.c", ccode);
		IFile cppfile = importFile("s.cpp", scode);
		waitUntilFileIsIndexed(index, cppfile);
		IASTNode decl;
		int offset1, offset2;

		offset1 = scode.indexOf("cxcpp");
		offset2 = scode.indexOf("cxcpp", offset1 + 1);
		testF3(cppfile, offset1);
		IEditorPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
		IEditorInput input = part.getEditorInput();
		assertEquals("s.c", ((FileEditorInput) input).getFile().getName());

		testF3(cppfile, offset2);
		part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
		input = part.getEditorInput();
		assertEquals("s.c", ((FileEditorInput) input).getFile().getName());

		offset1 = ccode.indexOf("cxcpp");
		testF3(cfile, offset1);
		part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
		input = part.getEditorInput();
		assertEquals("s.cpp", ((FileEditorInput) input).getFile().getName());
	}

	// void cxcpp();
	// void cfunc() {
	//    cxcpp();
	// }

	// void cppfunc() {}
	// extern "C" {void cxcpp() {
	//    cppfunc();
	// }}
	public void testNavigationCCallsCpp() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String ccode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile cfile = importFile("s.c", ccode);
		IFile cppfile = importFile("s.cpp", scode);
		waitUntilFileIsIndexed(index, cppfile);
		IASTNode decl;
		int offset1, offset2;

		offset1 = ccode.indexOf("cxcpp");
		offset2 = ccode.indexOf("cxcpp", offset1 + 1);
		testF3(cfile, offset1);
		IEditorPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
		IEditorInput input = part.getEditorInput();
		assertEquals("s.cpp", ((FileEditorInput) input).getFile().getName());

		testF3(cfile, offset2);
		part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
		input = part.getEditorInput();
		assertEquals("s.cpp", ((FileEditorInput) input).getFile().getName());

		offset1 = scode.indexOf("cxcpp");
		testF3(cppfile, offset1);
		part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
		input = part.getEditorInput();
		assertEquals("s.c", ((FileEditorInput) input).getFile().getName());
	}

	//    #define ADD_TEXT(txt1,txt2) txt1" "txt2
	//    #define ADD(a,b) (a + b)
	//    void main(void) {
	//    #if defined(ADD_TEXT) && defined(ADD)
	//    #endif
	//    }
	public void testNavigationInDefinedExpression_215906() throws Exception {
		StringBuilder[] buffers = getContents(1);
		String code = buffers[0].toString();
		IFile file = importFile("s.cpp", code);
		waitUntilFileIsIndexed(index, file);
		IASTNode decl;
		int offset1, offset2;

		offset1 = code.indexOf("ADD_TEXT");
		offset2 = code.indexOf("ADD_TEXT", offset1 + 1);
		decl = testF3(file, offset2);
		assertNode("ADD_TEXT", offset1, decl);

		offset1 = code.indexOf("ADD", offset1 + 1);
		offset2 = code.indexOf("ADD", offset2 + 1);
		decl = testF3(file, offset2);
		assertNode("ADD", offset1, decl);
	}

	//  struct X {
	//		int operator +(X);
	//      int operator [](int);
	//		~X();
	//	};
	//
	//	int test(X x) {
	//		x + x;
	//		x[6];
	//		X* xx = new X();
	//		delete xx;
	//	}
	public void testNavigationToImplicitNames() throws Exception {
		StringBuilder[] buffers = getContents(1);
		String code = buffers[0].toString();
		IFile file = importFile("in.cpp", code);
		waitUntilFileIsIndexed(index, file);

		int offset1 = code.indexOf("operator +");
		int offset2 = code.indexOf("+ x;");
		IASTNode decl = testF3(file, offset2);
		assertNode("operator +", offset1, decl);
		decl = testF3(file, offset2 + 1);
		assertNode("operator +", offset1, decl);

		offset1 = code.indexOf("operator []");
		offset2 = code.indexOf("[6];");
		decl = testF3(file, offset2 + 1);
		assertNode("operator []", offset1, decl);
		offset2 = code.indexOf("];");
		decl = testF3(file, offset2);
		assertNode("operator []", offset1, decl);
		decl = testF3(file, offset2 + 1);
		assertNode("operator []", offset1, decl);

		offset1 = code.indexOf("~X()");
		offset2 = code.indexOf("delete");
		decl = testF3(file, offset2);
		assertNode("~X", offset1, decl);
	}

	// template<typename T>
	// class C {
	// public:
	//    T operator+(int);
	// };

	// #include "test.h"
	// void main() {
	//   C<char> a;
	//   a + 2;
	// }
	public void testBug272744() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("test.h", hcode);
		IFile file = importFile("test.cpp", scode);
		waitUntilFileIsIndexed(index, file);

		int hoffset = hcode.indexOf("operator+");
		int soffset = scode.indexOf("+");
		IASTNode def = testF3(file, soffset + 1);
		assertTrue(def instanceof IASTName);
		assertEquals("operator +", ((IASTName) def).toString());
		assertEquals(hoffset, ((ASTNode) def).getOffset());
		assertEquals(9, ((ASTNode) def).getLength());
	}

	//    void  test(ABC* p);
	//    void  test(ABC* q) {}
	//    void call_test(){
	//    	test(0);
	//    }
	public void testBug305487() throws Exception {
		String code = getAboveComment();
		IFile file = importFile("testBug305487.cpp", code);
		waitUntilFileIsIndexed(index, file);

		int offset = code.indexOf("test(0)");
		IASTNode def = testF3(file, offset + 1);
		assertTrue(def instanceof IASTName);
	}

	//	struct A {
	//	  A();
	//	  A(int x);
	//	};

	//	#include "testImplicitConstructorCall_248855.h"
	//	void func() {
	//	  A a1;
	//	  A a2(5);
	//	}
	//	struct B {
	//	  B() : a3(1) {}
	//	  A a3;
	//	};
	public void testImplicitConstructorCall_248855() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("testImplicitConstructorCall_248855.h", hcode);
		IFile file = importFile("testImplicitConstructorCall_248855.cpp", scode);
		waitUntilFileIsIndexed(index, file);

		IASTNode target = testF3(file, scode.indexOf("a1"));
		assertTrue(target instanceof IASTName);
		assertEquals("A", ((IASTName) target).toString());
		assertEquals(hcode.indexOf("A()"), target.getFileLocation().getNodeOffset());
		assertEquals("A".length(), ((ASTNode) target).getLength());

		target = testF3(file, scode.indexOf("a2"));
		assertTrue(target instanceof IASTName);
		assertEquals("A", ((IASTName) target).toString());
		assertEquals(hcode.indexOf("A(int x)"), target.getFileLocation().getNodeOffset());
		assertEquals("A".length(), ((ASTNode) target).getLength());

		try {
			target = testF3(file, scode.indexOf("a3"));
			fail("Didn't expect navigation to succeed due to multiple choices: B::a3, A::A(int x).");
		} catch (RuntimeException e) {
			assertEquals("ambiguous input: 2", e.getMessage());
		}
	}

	// namespace ns {
	// void func();
	// }

	// #include "test.h"
	// using ns::func;
	//
	// void test() {
	//   func();
	// }
	public void testBug380197() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String hcode = buffers[0].toString();
		String scode = buffers[1].toString();
		IFile hfile = importFile("test.h", hcode);
		IFile file = importFile("test.cpp", scode);
		waitUntilFileIsIndexed(index, file);

		int hoffset = hcode.indexOf("func");
		int offset = scode.indexOf("func()");
		IASTNode def = testF3(file, offset + 1);
		assertTrue(def instanceof IASTName);
		assertEquals("func", def.toString());
		IASTFileLocation location = def.getFileLocation();
		assertEquals(hfile.getLocation().toOSString(), location.getFileName());
		assertEquals(hoffset, location.getNodeOffset());
	}

	//	int waldo(int a, decltype(a) b);
	public void testFunctionParameterReferencingPreviousParameter_432703() throws Exception {
		String code = getAboveComment();
		IFile file = importFile("test.cpp", code);
		waitUntilFileIsIndexed(index, file);

		int offset = code.indexOf("a)");
		IASTNode def = testF3(file, offset + 1);
		assertTrue(def instanceof IASTName);
	}

	//  #define WALDO 42

	//  #define WALDO 98

	//  #include "a.hpp"
	//  int x = WALDO;
	public void testTwoMacrosWithSameName_440940() throws Exception {
		StringBuilder[] buffers = getContents(3);
		String aHpp = buffers[0].toString();
		String bHpp = buffers[1].toString();
		String cpp = buffers[2].toString();
		IFile aHppFile = importFile("a.hpp", aHpp);
		IFile bHppFile = importFile("b.hpp", bHpp);
		IFile cppFile = importFile("test.cpp", cpp);
		waitUntilFileIsIndexed(index, cppFile);

		IASTNode result = testF3(cppFile, cpp.indexOf("WALDO") + 1);
		assertTrue(result instanceof IASTName);
		IBinding binding = ((IASTName) result).resolveBinding();
		assertTrue(binding instanceof IMacroBinding);
		String expansion = new String(((IMacroBinding) binding).getExpansion());
		assertTrue(expansion.contains("42"));
	}

	//    #define DEFINE_FUNC(...) void foo() { __VA_ARGS__ }
	//    struct Waldo {
	//        void find();
	//    };
	//    DEFINE_FUNC
	//    (
	//        Waldo waldo;
	//        waldo.find();
	//    )
	public void testDeclarationInMacroArgment_509733() throws Exception {
		String code = getAboveComment();
		IFile file = importFile("test.cpp", code);
		waitUntilFileIsIndexed(index, file);

		int offset = code.indexOf("waldo.find()");
		IASTNode def = testF3(file, offset + 1);
		assertTrue(def instanceof IASTName);
	}

	//	class Waldo {
	//	    void find();
	//	};

	//	#include "test.hpp"
	//	int Waldo::find() {}
	public void testNavigationToDefinitionWithWrongSignature_525739() throws Exception {
		StringBuilder[] buffers = getContents(3);
		String hpp = buffers[0].toString();
		String cpp = buffers[1].toString();
		IFile hppFile = importFile("test.hpp", hpp);
		IFile cppFile = importFile("test.cpp", cpp);
		waitUntilFileIsIndexed(index, cppFile);

		// We should find the definition, even though the signature doesn't match exactly.
		IASTNode target = testF3(hppFile, hpp.indexOf("void find") + 6);
		assertInstance(target, IASTName.class);
		assertEquals(IASTNameOwner.r_definition, ((IASTName) target).getRoleOfName(false));
	}

	//	class Waldo {
	//	    void find();
	//	};

	//	#include "test.hpp"
	//	void Waldo::find() {}
	//	int Waldo::find() {}
	public void testNavigationPrefersCorrectDefinition_525739() throws Exception {
		StringBuilder[] buffers = getContents(3);
		String hpp = buffers[0].toString();
		String cpp = buffers[1].toString();
		IFile hppFile = importFile("test.hpp", hpp);
		IFile cppFile = importFile("test.cpp", cpp);
		waitUntilFileIsIndexed(index, cppFile);

		// We should find the definition that's an exact match, rather than asking the
		// user to disambiguate between two alternatives.
		IASTNode target = testF3(hppFile, hpp.indexOf("void find") + 6);
		assertInstance(target, IASTName.class);
		assertEquals(IASTNameOwner.r_definition, ((IASTName) target).getRoleOfName(false));
	}

	//	template <typename E>
	//	struct Node {
	//		Node * next;
	//		E value;
	//	};
	//	Node<int> head{nullptr, 42};
	//	auto [h, v] = head;

	//	#include "SBTestHeader.hpp"
	//	auto myH = h;
	//	auto myV = v;
	public void testNavigationToStructuredBinding_522200() throws Exception {
		StringBuilder[] buffers = getContents(2);
		String header = buffers[0].toString();
		IFile headerFile = importFile("SBTestHeader.hpp", header);
		String source = buffers[1].toString();
		IFile sourceFile = importFile("SBTestSource.cpp", source);
		waitUntilFileIsIndexed(index, sourceFile);

		IASTNode targetH = testF3(sourceFile, source.indexOf("myH = h") + 6);
		assertInstance(targetH, IASTName.class);
		assertEquals(IASTNameOwner.r_definition, ((IASTName) targetH).getRoleOfName(false));
		IASTFileLocation locationH = targetH.getFileLocation();
		int targetHOffset = locationH.getNodeOffset();
		assertEquals(header.indexOf("auto [h") + 6, targetHOffset);

		IASTNode targetV = testF3(sourceFile, source.indexOf("myV = v") + 6);
		assertInstance(targetV, IASTName.class);
		assertEquals(IASTNameOwner.r_definition, ((IASTName) targetV).getRoleOfName(false));
		IASTFileLocation locationV = targetV.getFileLocation();
		int targetVOffset = locationV.getNodeOffset();
		assertEquals(header.indexOf("[h, v") + 4, targetVOffset);
	}
}