diff options
Diffstat (limited to 'lrparser/org.eclipse.cdt.core.lrparser.tests/src/org/eclipse/cdt/core/lrparser/tests/LRCompletionParseTest.java')
| -rw-r--r-- | lrparser/org.eclipse.cdt.core.lrparser.tests/src/org/eclipse/cdt/core/lrparser/tests/LRCompletionParseTest.java | 415 |
1 files changed, 415 insertions, 0 deletions
diff --git a/lrparser/org.eclipse.cdt.core.lrparser.tests/src/org/eclipse/cdt/core/lrparser/tests/LRCompletionParseTest.java b/lrparser/org.eclipse.cdt.core.lrparser.tests/src/org/eclipse/cdt/core/lrparser/tests/LRCompletionParseTest.java new file mode 100644 index 00000000000..373d3c2a213 --- /dev/null +++ b/lrparser/org.eclipse.cdt.core.lrparser.tests/src/org/eclipse/cdt/core/lrparser/tests/LRCompletionParseTest.java @@ -0,0 +1,415 @@ +/******************************************************************************* + * Copyright (c) 2006, 2009 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.core.lrparser.tests; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +import junit.framework.TestCase; +import junit.framework.TestSuite; + +import org.eclipse.cdt.core.dom.ast.IASTCompletionNode; +import org.eclipse.cdt.core.dom.ast.IASTName; +import org.eclipse.cdt.core.dom.ast.IBinding; +import org.eclipse.cdt.core.dom.ast.IEnumerator; +import org.eclipse.cdt.core.dom.ast.IField; +import org.eclipse.cdt.core.dom.ast.ITypedef; +import org.eclipse.cdt.core.dom.ast.IVariable; +import org.eclipse.cdt.core.dom.lrparser.gnu.GCCLanguage; +import org.eclipse.cdt.core.model.ILanguage; + + +/** + * Reuse the completion parse tests from the old parser for now. + */ +@SuppressWarnings("nls") +public class LRCompletionParseTest extends TestCase { + + public static TestSuite suite() { + return new TestSuite(LRCompletionParseTest.class); + } + + + public LRCompletionParseTest() { } + public LRCompletionParseTest(String name) { super(name); } + + + protected IASTCompletionNode parse(String code, int offset) throws Exception { + return ParseHelper.getCompletionNode(code, getCLanguage(), offset); + } + + + private static final Comparator<IBinding> BINDING_COMPARATOR = new Comparator<IBinding>() { + public int compare(IBinding b1, IBinding b2) { + return b1.getName().compareTo(b2.getName()); + } + }; + + + public static IBinding[] getBindings(IASTName[] names) { + List<IBinding> bindings = new ArrayList<IBinding>(); + + for(IASTName name : names) { + if(name.getTranslationUnit() == null) + continue; + + for(IBinding binding : name.getCompletionContext().findBindings(name, true)) + bindings.add(binding); + } + + Collections.sort(bindings, BINDING_COMPARATOR); + return bindings.toArray(new IBinding[bindings.size()]); + } + + + protected ILanguage getCLanguage() { + return GCCLanguage.getDefault(); + } + + + // First steal tests from CompletionParseTest + + + public void testCompletionStructField() throws Exception { + String code = + "int aVar; " + + "struct D{ " + + " int aField1; " + + " int aField2; " + + "}; " + + "void foo(){" + + " struct D d; " + + " d.a " + + "}\n"; + + int index = code.indexOf( "d.a" ); + + IASTCompletionNode node = parse( code, index + 3 ); + assertNotNull( node ); + + String prefix = node.getPrefix(); + assertNotNull( prefix ); + assertEquals( prefix, "a" ); + + IASTName[] names = node.getNames(); + assertEquals(1, names.length); + + IBinding[] bindings = getBindings(names); + + assertEquals(2, bindings.length); + assertEquals("aField1", ((IField)bindings[0]).getName()); + assertEquals("aField2", ((IField)bindings[1]).getName()); + } + + public void testCompletionStructFieldPointer() throws Exception { + String code = + "struct Cube { " + + " int nLen; " + + " int nWidth; " + + " int nHeight; " + + "}; " + + "int volume( struct Cube * pCube ) { " + + " pCube->SP "; + + IASTCompletionNode node = parse( code, code.indexOf("SP")); + + IASTName[] names = node.getNames(); + assertEquals(1, names.length); + + IBinding[] bindings = getBindings(names); + + assertEquals(3, bindings.length); + assertEquals("nHeight", ((IField)bindings[0]).getName()); + assertEquals("nLen", ((IField)bindings[1]).getName()); + assertEquals("nWidth", ((IField)bindings[2]).getName()); + } + + + public void testCompletionParametersAsLocalVariables() throws Exception{ + String code = + "int foo( int aParameter ){" + + " int aLocal;" + + " if( aLocal != 0 ){" + + " int aBlockLocal;" + + " a \n"; + + int index = code.indexOf( " a " ); + + IASTCompletionNode node = parse( code, index + 2 ); + assertNotNull( node ); + + assertEquals("a", node.getPrefix()); //$NON-NLS-1$ + + IASTName[] names = node.getNames(); + assertEquals(2, names.length); + + IBinding[] bindings = getBindings(names); + + assertEquals(3, bindings.length); + assertEquals("aBlockLocal", ((IVariable)bindings[0]).getName()); + assertEquals("aLocal", ((IVariable)bindings[1]).getName()); + assertEquals("aParameter", ((IVariable)bindings[2]).getName()); + } + + + public void testCompletionTypedef() throws Exception { + String code = + "typedef int Int; " + + "InSP"; + + int index = code.indexOf( "SP" ); + + IASTCompletionNode node = parse( code, index ); + assertNotNull(node); + + IASTName[] names = node.getNames(); + assertEquals(1, names.length); + + assertEquals("In", node.getPrefix()); + + IBinding[] bindings = getBindings(names); + + assertEquals(1, bindings.length); + assertEquals("Int", ((ITypedef)bindings[0]).getName()); + } + + public void testCompletion() throws Exception { + String code = + "#define GL_T 0x2001\n" + + "#define GL_TRUE 0x1\n" + + "typedef unsigned char GLboolean;\n" + + "static GLboolean should_rotate = GL_T"; + + int index = code.indexOf("= GL_T"); + + IASTCompletionNode node = parse( code, index + 6); + assertNotNull(node); + + assertEquals("GL_T", node.getPrefix()); //$NON-NLS-1$ + + IASTName[] names = node.getNames(); + assertEquals(1, names.length); + } + + public void testCompletionInTypeDef() throws Exception { + String code = + "struct A { int name; }; \n" + + "typedef struct A * PA; \n" + + "int main() { \n" + + " PA a; \n" + + " a->SP \n" + + "} \n"; + + int index = code.indexOf("SP"); //$NON-NLS-1$ + + IASTCompletionNode node = parse( code, index ); + assertNotNull( node ); + + + IASTName[] names = node.getNames(); + assertEquals(1, names.length); + + IBinding[] bindings = getBindings(names); + + assertEquals(1, bindings.length); + assertEquals("name", ((IField)bindings[0]).getName()); + } + + + public void _testCompletionFunctionCall() throws Exception { + String code = + "struct A { \n" + + " int f2; \n" + + " int f4; \n" + + "}; \n" + + "const A * foo(){} \n" + + "void main( ) \n" + + "{ \n" + + " foo()->SP \n"; + + int index = code.indexOf( "SP" ); + + IASTCompletionNode node = parse( code, index ); + assertNotNull( node ); + + IASTName[] names = node.getNames(); + assertEquals(1, names.length); + + IBinding[] bindings = getBindings(names); + + assertEquals(2, bindings.length); + assertEquals("f2", ((IField)bindings[0]).getName()); + assertEquals("f4", ((IField)bindings[1]).getName()); + } + + + public void _testCompletionSizeof() throws Exception { + String code = + "int f() {\n" + + "short blah;\n" + + "int x = sizeof(bl"; + + int index = code.indexOf( "of(bl" ); + + IASTCompletionNode node = parse( code, index + 5); + assertNotNull( node ); + + IASTName[] names = node.getNames(); + assertEquals(1, names.length); + + IBinding[] bindings = getBindings(names); + + assertEquals(1, bindings.length); + assertEquals("blah", ((IVariable)bindings[0]).getName()); + } + + + public void testCompletionForLoop() throws Exception { + String code = + "int f() {\n" + + " int biSizeImage = 5;\n" + + "for (int i = 0; i < bi "; + + int index = code.indexOf("< bi"); + + IASTCompletionNode node = parse( code, index + 4); + assertNotNull( node ); + + IASTName[] names = node.getNames(); + assertEquals(1, names.length); + + IBinding[] bindings = getBindings(names); + + assertEquals(1, bindings.length); + assertEquals("biSizeImage", ((IVariable)bindings[0]).getName()); + } + + + + public void testCompletionStructPointer() throws Exception { + String code = + " struct Temp { char * total; };" + + " int f(struct Temp * t) {" + + " t->t[5] = t->"; + + int index = code.indexOf("= t->"); + + IASTCompletionNode node = parse( code, index + 5); + assertNotNull( node ); + + IASTName[] names = node.getNames(); + assertEquals(1, names.length); + + IBinding[] bindings = getBindings(names); + + assertEquals(1, bindings.length); + assertEquals("total", ((IVariable)bindings[0]).getName()); + } + + + public void testCompletionEnum() throws Exception { + String code = + "typedef int DWORD;\n" + + "typedef char BYTE;\n" + + "#define MAKEFOURCC(ch0, ch1, ch2, ch3) \\\n" + + "((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \\\n" + + "((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))\n" + + "enum e {\n" + + "blah1 = 5,\n" + + "blah2 = MAKEFOURCC('a', 'b', 'c', 'd'),\n" + + "blah3\n" + + "};\n" + + "e mye = bl\n"; + + int index = code.indexOf("= bl"); + + IASTCompletionNode node = parse( code, index + 4); + assertNotNull( node ); + + IASTName[] names = node.getNames(); + assertEquals(1, names.length); + + IBinding[] bindings = getBindings(names); + + assertEquals(3, bindings.length); + assertEquals("blah1", ((IEnumerator)bindings[0]).getName()); + assertEquals("blah2", ((IEnumerator)bindings[1]).getName()); + assertEquals("blah3", ((IEnumerator)bindings[2]).getName()); + } + + + public void testCompletionStructArray() throws Exception { + String code = + "struct packet { int a; int b; };\n" + + "struct packet buffer[5];\n" + + "int main(int argc, char **argv) {\n" + + " buffer[2]."; + + int index = code.indexOf("[2]."); + + IASTCompletionNode node = parse( code, index + 4); + assertNotNull( node ); + + IASTName[] names = node.getNames(); + assertEquals(1, names.length); + + IBinding[] bindings = getBindings(names); + + assertEquals(2, bindings.length); + assertEquals("a", ((IField)bindings[0]).getName()); + assertEquals("b", ((IField)bindings[1]).getName()); + } + + + public void testCompletionPreprocessorDirective() throws Exception { + IASTCompletionNode node = parse("#", 1); + assertNotNull( node ); + + IASTName[] names = node.getNames(); + assertEquals(1, names.length); + + //assertEquals("#", node.getPrefix()); + } + + public void testCompletionPreprocessorMacro() throws Exception { + String code = + "#define AMACRO 99 \n" + + "int main() { \n" + + " int AVAR; \n" + + " int x = A \n"; + + int index = code.indexOf("= A"); + + IASTCompletionNode node = parse( code, index + 3); + assertNotNull( node ); + + IASTName[] names = node.getNames(); + assertEquals(1, names.length); + assertEquals("A", node.getPrefix()); + } + + + public void testCompletionInsidePreprocessorDirective() throws Exception { + String code = + "#define MAC1 99 \n" + + "#define MAC2 99 \n" + + "#ifdef MA"; + + int index = code.length(); + + IASTCompletionNode node = parse( code, index ); + assertNotNull( node ); + + assertEquals("MA", node.getPrefix()); + } +} |