From 1c8f7f56379124256526bbc98b30e8df51626b9c Mon Sep 17 00:00:00 2001 From: Doug Schaefer Date: Wed, 16 Apr 2003 20:32:20 +0000 Subject: [PATCH] Patch for Hoda Amer: - Fix for bug 36506: Bad Signature For main - Fix for bug 36498: outline view signature incorrect for templated functions/methods - JUnit tests for C Model Elements. --- .../eclipse/cdt/core/model/IEnumeration.java | 2 +- .../eclipse/cdt/core/model/IEnumerator.java | 2 +- .../core/model/FunctionDeclaration.java | 19 +- .../internal/core/model/FunctionTemplate.java | 7 +- .../internal/core/model/MethodTemplate.java | 7 +- .../internal/core/model/CModelBuilder.java | 16 +- .../core/model/tests/CModelElementsTests.java | 333 ++++++++++++++++-- .../core/model/tests/ElementDeltaTests.java | 16 + .../core/model/tests/WorkingCopyTests.java | 19 + .../cfiles/CModelElementsTestStart.h | 115 +++++- 10 files changed, 499 insertions(+), 37 deletions(-) diff --git a/core/org.eclipse.cdt.core/model/org/eclipse/cdt/core/model/IEnumeration.java b/core/org.eclipse.cdt.core/model/org/eclipse/cdt/core/model/IEnumeration.java index 0ea78c05c1e..595a0604ffb 100644 --- a/core/org.eclipse.cdt.core/model/org/eclipse/cdt/core/model/IEnumeration.java +++ b/core/org.eclipse.cdt.core/model/org/eclipse/cdt/core/model/IEnumeration.java @@ -8,5 +8,5 @@ package org.eclipse.cdt.core.model; /** * An Enumeration type. */ -public interface IEnumeration extends IVariable { +public interface IEnumeration extends IVariable, IParent { } diff --git a/core/org.eclipse.cdt.core/model/org/eclipse/cdt/core/model/IEnumerator.java b/core/org.eclipse.cdt.core/model/org/eclipse/cdt/core/model/IEnumerator.java index c9075c250b9..a9a08a5ac54 100644 --- a/core/org.eclipse.cdt.core/model/org/eclipse/cdt/core/model/IEnumerator.java +++ b/core/org.eclipse.cdt.core/model/org/eclipse/cdt/core/model/IEnumerator.java @@ -10,7 +10,7 @@ package org.eclipse.cdt.core.model; * Contributors: * Rational Software - Initial API and implementation ***********************************************************************/ -public interface IEnumerator extends ISourceManipulation{ +public interface IEnumerator extends ICElement, ISourceManipulation{ /** * Returns the enumerator constant expression if any. diff --git a/core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/model/FunctionDeclaration.java b/core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/model/FunctionDeclaration.java index bd079ec9b74..019cd639cb0 100644 --- a/core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/model/FunctionDeclaration.java +++ b/core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/model/FunctionDeclaration.java @@ -51,6 +51,17 @@ public class FunctionDeclaration extends SourceManipulation implements IFunction public String getSignature(){ StringBuffer sig = new StringBuffer(getElementName()); + sig.append(getParameterClause()); + if(isConst()) + sig.append(" const"); + if(isVolatile()) + sig.append(" volatile"); + return sig.toString(); + } + + public String getParameterClause(){ + StringBuffer sig = new StringBuffer(); + if(getNumberOfParameters() > 0){ sig.append("("); String[] paramTypes = getParameterTypes(); @@ -65,13 +76,9 @@ public class FunctionDeclaration extends SourceManipulation implements IFunction else{ sig.append("()"); } - if(isConst()) - sig.append(" const"); - if(isVolatile()) - sig.append(" volatile"); - return sig.toString(); + return sig.toString(); } - + public String getParameterInitializer(int pos) { return ""; } diff --git a/core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/model/FunctionTemplate.java b/core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/model/FunctionTemplate.java index 4b2293c6bc9..392bf3f7359 100644 --- a/core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/model/FunctionTemplate.java +++ b/core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/model/FunctionTemplate.java @@ -66,7 +66,12 @@ public class FunctionTemplate extends FunctionDeclaration implements ITemplate{ else{ sig.append("<>"); } - sig.append(this.getSignature()); + sig.append(this.getParameterClause()); + if(isConst()) + sig.append(" const"); + if(isVolatile()) + sig.append(" volatile"); + if((this.getReturnType() != null) && (this.getReturnType().length() > 0)){ sig.append(" : "); sig.append(this.getReturnType()); diff --git a/core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/model/MethodTemplate.java b/core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/model/MethodTemplate.java index 6a97e251085..b2e8e988ca9 100644 --- a/core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/model/MethodTemplate.java +++ b/core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/model/MethodTemplate.java @@ -66,7 +66,12 @@ public class MethodTemplate extends MethodDeclaration implements ITemplate{ else{ sig.append("<>"); } - sig.append(this.getSignature()); + sig.append(this.getParameterClause()); + if(isConst()) + sig.append(" const"); + if(isVolatile()) + sig.append(" volatile"); + if((this.getReturnType() != null) && (this.getReturnType().length() > 0)){ sig.append(" : "); sig.append(this.getReturnType()); diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/model/CModelBuilder.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/model/CModelBuilder.java index 530261a8c10..2dfcc7ba839 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/model/CModelBuilder.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/model/CModelBuilder.java @@ -24,6 +24,7 @@ import org.eclipse.cdt.core.model.IParent; import org.eclipse.cdt.core.model.IStructure; import org.eclipse.cdt.core.model.ITemplate; import org.eclipse.cdt.core.model.ITranslationUnit; +import org.eclipse.cdt.internal.core.dom.ArrayQualifier; import org.eclipse.cdt.internal.core.dom.ClassKey; import org.eclipse.cdt.internal.core.dom.ClassSpecifier; import org.eclipse.cdt.internal.core.dom.DOMBuilder; @@ -535,7 +536,6 @@ public class CModelBuilder { if(decl instanceof TemplateParameter){ TemplateParameter parameter = (TemplateParameter) decl; if(parameter.getName() != null){ - paramType.append(" "); paramType.append(parameter.getName().toString()); }else { int kind = parameter.getKind(); @@ -577,6 +577,7 @@ public class CModelBuilder { type.append(getDeclarationType(declaration)); // add pointerr or reference from declarator if any type.append(getDeclaratorPointerOperation(declarator)); + type.append(getDeclaratorArrayQualifiers(declarator)); return type.toString(); } @@ -663,4 +664,17 @@ public class CModelBuilder { } return pointerString.toString(); } + + private String getDeclaratorArrayQualifiers(Declarator declarator){ + StringBuffer arrayString = new StringBuffer(); + List arrayQualifiers = declarator.getArrayQualifiers(); + if(arrayQualifiers != null){ + Iterator i = arrayQualifiers.iterator(); + while (i.hasNext()){ + ArrayQualifier q = (ArrayQualifier) i.next(); + arrayString.append("[]"); + } + } + return arrayString.toString(); + } } diff --git a/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/CModelElementsTests.java b/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/CModelElementsTests.java index 7597a32da50..3af3a0d6568 100644 --- a/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/CModelElementsTests.java +++ b/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/CModelElementsTests.java @@ -21,11 +21,25 @@ import org.eclipse.cdt.core.CCProjectNature; import org.eclipse.cdt.core.CCorePlugin; import org.eclipse.cdt.core.model.ICElement; import org.eclipse.cdt.core.model.ICProject; +import org.eclipse.cdt.core.model.IEnumeration; +import org.eclipse.cdt.core.model.IEnumerator; import org.eclipse.cdt.core.model.IField; +import org.eclipse.cdt.core.model.IFunction; +import org.eclipse.cdt.core.model.IFunctionDeclaration; +import org.eclipse.cdt.core.model.IInclude; +import org.eclipse.cdt.core.model.IMacro; import org.eclipse.cdt.core.model.IMember; import org.eclipse.cdt.core.model.IMethod; +import org.eclipse.cdt.core.model.IMethodDeclaration; import org.eclipse.cdt.core.model.INamespace; +import org.eclipse.cdt.core.model.IParent; import org.eclipse.cdt.core.model.IStructure; +import org.eclipse.cdt.core.model.ITypeDef; +import org.eclipse.cdt.core.model.IVariable; +import org.eclipse.cdt.core.model.IVariableDeclaration; +import org.eclipse.cdt.internal.core.model.ClassTemplate; +import org.eclipse.cdt.internal.core.model.FunctionTemplate; +import org.eclipse.cdt.internal.core.model.MethodTemplate; import org.eclipse.cdt.internal.core.model.TranslationUnit; import org.eclipse.cdt.testplugin.CProjectHelper; import org.eclipse.cdt.testplugin.TestPluginLauncher; @@ -75,7 +89,16 @@ public class CModelElementsTests extends TestCase { } CCorePlugin.getDefault().setUseNewParser(true); + } + private static void addNatureToProject(IProject proj, String natureId, IProgressMonitor monitor) throws CoreException { + IProjectDescription description = proj.getDescription(); + String[] prevNatures= description.getNatureIds(); + String[] newNatures= new String[prevNatures.length + 1]; + System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length); + newNatures[prevNatures.length]= natureId; + description.setNatureIds(newNatures); + proj.setDescription(description, monitor); } protected void tearDown() throws Exception { @@ -87,43 +110,309 @@ public class CModelElementsTests extends TestCase { // parse the translation unit to get the elements tree tu.parse(); - // tu ---> namespace MyPackage + // tu ---> include + checkInclude(tu); + + // tu ---> macro + checkMacro(tu); + + // tu ---> namespace: MyPackage ArrayList tuPackages = tu.getChildrenOfType(ICElement.C_NAMESPACE); INamespace namespace = (INamespace) tuPackages.get(0); assertEquals(namespace.getElementName(), new String("MyPackage")); - // MyPackage ---> class Hello - ArrayList nsClassChildren = namespace.getChildrenOfType(ICElement.C_CLASS); - IStructure classHello = (IStructure) nsClassChildren.get(0); + checkClass(namespace); + + checkEnums(namespace); + + checkVariables(namespace); + + checkVariableDeclarations(namespace); + + checkFunctions(namespace); + + checkStructs(namespace); + + checkTemplates(namespace); + + checkArrays(tu); + } + + private void checkInclude(IParent tu){ + ArrayList tuIncludes = tu.getChildrenOfType(ICElement.C_INCLUDE); + IInclude inc1 = (IInclude) tuIncludes.get(0); + assertEquals(inc1.getElementName(), new String("stdio.h")); + } + + private void checkMacro(IParent tu){ + ArrayList tuMacros = tu.getChildrenOfType(ICElement.C_MACRO); + IMacro mac1 = (IMacro) tuMacros.get(0); + assertEquals(mac1.getElementName(), new String("PRINT")); + } + + private void checkClass(IParent namespace){ + // MyPackage ---> class: Hello + ArrayList nsClasses = namespace.getChildrenOfType(ICElement.C_CLASS); + IStructure classHello = (IStructure) nsClasses.get(0); assertEquals(classHello.getElementName(), new String("Hello")); - // Hello --> int x - ArrayList helloFieldChildren = classHello.getChildrenOfType(ICElement.C_FIELD); - IField intX = (IField) helloFieldChildren.get(0); + // Hello --> field: int x + ArrayList helloFields = classHello.getChildrenOfType(ICElement.C_FIELD); + IField intX = (IField) helloFields.get(0); assertEquals(intX.getElementName(), new String("x")); - int visibility = intX.getVisibility(); - if (visibility != IMember.V_PROTECTED) + assertEquals(intX.getTypeName(), new String("int")); + int xVisibility = intX.getVisibility(); + if (xVisibility != IMember.V_PROTECTED) fail("visibility should be protected!"); - - // Hello ---> void setX(int X) - ArrayList helloMethodChildren = classHello.getChildrenOfType(ICElement.C_METHOD); - IMethod setX = (IMethod) helloMethodChildren.get(0); + // Hello ---> method: void setX(int X) + ArrayList helloMethods = classHello.getChildrenOfType(ICElement.C_METHOD); + IMethod setX = (IMethod) helloMethods.get(0); assertEquals(setX.getElementName(), new String("setX")); + assertEquals(setX.getReturnType(), new String("void")); int setXNumOfParam = setX.getNumberOfParameters(); if(setXNumOfParam != 1) fail("setX should have one parameter!"); String[] setXParamTypes = setX.getParameterTypes(); String firstParamType = setXParamTypes[0]; - assertEquals(firstParamType, new String("int")); + assertEquals(firstParamType, new String("int")); + // TODO : check for the inline here + + checkNestedNamespace(classHello); } - private static void addNatureToProject(IProject proj, String natureId, IProgressMonitor monitor) throws CoreException { - IProjectDescription description = proj.getDescription(); - String[] prevNatures= description.getNatureIds(); - String[] newNatures= new String[prevNatures.length + 1]; - System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length); - newNatures[prevNatures.length]= natureId; - description.setNatureIds(newNatures); - proj.setDescription(description, monitor); + private void checkNestedNamespace(IParent classHello){ + // Hello ---> namespace: MyNestedPackage + ArrayList helloNamespaces = classHello.getChildrenOfType(ICElement.C_NAMESPACE); + INamespace myNestedPackage = (INamespace) helloNamespaces.get(0); + assertEquals(myNestedPackage.getElementName(), new String("MyNestedPackage")); + + checkParentNestedClass(myNestedPackage); + checkDerivedNestedClass(myNestedPackage); } + private void checkParentNestedClass(IParent myNestedPackage){ + // MyNestedPackage ---> class: Y + ArrayList nestedClasses = myNestedPackage.getChildrenOfType(ICElement.C_CLASS); + IStructure classY = (IStructure) nestedClasses.get(0); + assertEquals(classY.getElementName(), new String("Y")); + + // Y ---> constructor: Y + ArrayList yMethods = classY.getChildrenOfType(ICElement.C_METHOD_DECLARATION); + IMethodDeclaration constructor = (IMethodDeclaration) yMethods.get(0); + assertEquals(constructor.getElementName(), new String("Y")); + assertTrue (constructor.isConstructor()); + + // Y ---> destructor: ~Y + IMethodDeclaration destructor = (IMethodDeclaration) yMethods.get(1); + assertEquals(destructor.getElementName(), new String("~Y")); + assertTrue (destructor.isDestructor()); + // TODO: check for virtual on destructors + + } + + private void checkDerivedNestedClass(IParent myNestedPackage){ + // MyNestedPackage ---> class: X public Y + ArrayList nestedClasses = myNestedPackage.getChildrenOfType(ICElement.C_CLASS); + IStructure classX = (IStructure) nestedClasses.get(1); + assertEquals(classX.getElementName(), new String("X")); + // TODO : Check for base classes here + + // X --> field: B b + ArrayList xFieldChildren = classX.getChildrenOfType(ICElement.C_FIELD); + IField bB = (IField) xFieldChildren.get(0); + assertEquals(bB.getElementName(), new String("b")); + assertEquals(bB.getTypeName(), new String("B")); + int bVisibility = bB.getVisibility(); + if (bVisibility != IMember.V_PRIVATE) + fail("visibility should be private!"); + + // X ---> constructor chain: X + ArrayList xMethodChildren = classX.getChildrenOfType(ICElement.C_METHOD); + IMethod xconstructor = (IMethod) xMethodChildren.get(0); + assertEquals(xconstructor.getElementName(), new String("X")); + assertTrue (xconstructor.isConstructor()); + + // X ---> method declaration: doNothing + ArrayList xMethodDeclarations = classX.getChildrenOfType(ICElement.C_METHOD_DECLARATION); + IMethodDeclaration xDoNothing = (IMethodDeclaration) xMethodDeclarations.get(0); + assertEquals(xDoNothing.getElementName(), new String("doNothing")); + assertEquals(xDoNothing.getReturnType(), new String("int")); + } + + private void checkEnums(IParent namespace){ + // MyPackage ---> enum: Noname + ArrayList nsEnums = namespace.getChildrenOfType(ICElement.C_ENUMERATION); + IEnumeration enum = (IEnumeration) nsEnums.get(0); + assertEquals(enum.getElementName(), new String("")); + + // enum ---> enumerator: first + ArrayList enumEnumerators = enum.getChildrenOfType(ICElement.C_ENUMERATOR); + IEnumerator first = (IEnumerator) enumEnumerators.get(0); + assertEquals(first.getElementName(), new String("first")); + // enum ---> enumerator: second + IEnumerator second = (IEnumerator) enumEnumerators.get(1); + assertEquals(second.getElementName(), new String("second")); + // enum ---> enumerator: third + IEnumerator third = (IEnumerator) enumEnumerators.get(2); + assertEquals(third.getElementName(), new String("third")); + + // MyPackage ---> enum: MyEnum + IEnumeration myEnum = (IEnumeration) nsEnums.get(1); + assertEquals(myEnum.getElementName(), new String("MyEnum")); + + // enum ---> enumerator: first + ArrayList myEnumEnumerators = myEnum.getChildrenOfType(ICElement.C_ENUMERATOR); + IEnumerator f = (IEnumerator) myEnumEnumerators.get(0); + assertEquals(f.getElementName(), new String("f")); + // enum ---> enumerator: second + IEnumerator s = (IEnumerator) myEnumEnumerators.get(1); + assertEquals(s.getElementName(), new String("s")); + // enum ---> enumerator: third + IEnumerator t = (IEnumerator) myEnumEnumerators.get(2); + assertEquals(t.getElementName(), new String("t")); + } + + private void checkVariables(IParent namespace){ + // MyPackage ---> int v + ArrayList nsVars = namespace.getChildrenOfType(ICElement.C_VARIABLE); + IVariable var1 = (IVariable) nsVars.get(0); + assertEquals(var1.getElementName(), new String("v")); + assertEquals(var1.getTypeName(), new String("int")); + + // MyPackage ---> unsigned long vuLong + IVariable var2 = (IVariable) nsVars.get(1); + assertEquals(var2.getElementName(), new String("vuLong")); + assertEquals(var2.getTypeName(), new String("unsigned long ")); + + // MyPackage ---> unsigned short vuShort + IVariable var3 = (IVariable) nsVars.get(2); + assertEquals(var3.getElementName(), new String("vuShort")); + assertEquals(var3.getTypeName(), new String("unsigned short ")); + } + + private void checkVariableDeclarations(IParent namespace){ + // MyPackage ---> extern int evar + ArrayList nsVarDecls = namespace.getChildrenOfType(ICElement.C_VARIABLE_DECLARATION); + IVariableDeclaration vDecl1 = (IVariableDeclaration) nsVarDecls.get(0); + assertEquals(vDecl1.getElementName(), new String("evar")); + assertEquals(vDecl1.getTypeName(), new String("int")); + + // MyPackage ---> function pointer: orig_malloc_hook + IVariableDeclaration vDecl2 = (IVariableDeclaration) nsVarDecls.get(1); + assertEquals(vDecl2.getElementName(), new String("orig_malloc_hook")); + assertEquals(vDecl2.getTypeName(), new String ("void*(*)(const char*, int, size_t)")); + } + + private void checkFunctions(IParent namespace){ + // MyPackage ---> function: void foo() + ArrayList nsFunctionDeclarations = namespace.getChildrenOfType(ICElement.C_FUNCTION_DECLARATION); + IFunctionDeclaration f1 = (IFunctionDeclaration) nsFunctionDeclarations.get(0); + assertEquals(f1.getElementName(), new String("foo")); + assertEquals(f1.getReturnType(), new String("void")); + + // MyPackage ---> function: char* foo(int&, char**) + IFunctionDeclaration f2 = (IFunctionDeclaration) nsFunctionDeclarations.get(1); + assertEquals(f2.getElementName(), new String("foo")); + assertEquals(f2.getReturnType(), new String("char*")); + int fooNumOfParam = f2.getNumberOfParameters(); + if(fooNumOfParam != 2) + fail("foo should have two parameter!"); + String[] paramTypes = f2.getParameterTypes(); + assertEquals(paramTypes[0], new String("int&")); + assertEquals(paramTypes[1], new String("char**")); + + // MyPackage ---> function: void boo() {} + ArrayList nsFunctions = namespace.getChildrenOfType(ICElement.C_FUNCTION); + IFunction f3 = (IFunction) nsFunctions.get(0); + assertEquals(f3.getElementName(), new String("boo")); + assertEquals(f3.getReturnType(), new String("void")); + } + + private void checkStructs(IParent namespace){ + // struct with name + ArrayList nsStructs = namespace.getChildrenOfType(ICElement.C_STRUCT); + IStructure struct1 = (IStructure) nsStructs.get(0); + assertEquals(struct1.getElementName(), new String ("MyStruct")); + ArrayList struct1Fields = struct1.getChildrenOfType(ICElement.C_FIELD); + IField field1 = (IField) struct1Fields.get(0); + assertEquals(field1.getElementName(), new String("sint")); + assertEquals(field1.getTypeName(), new String("int")); + if(field1.getVisibility() != IMember.V_PUBLIC) + fail("field visibility should be public!"); + + // struct no name + IStructure struct2 = (IStructure) nsStructs.get(1); + assertEquals(struct2.getElementName(), new String ("")); + ArrayList struct2Fields = struct2.getChildrenOfType(ICElement.C_FIELD); + IField field2 = (IField) struct2Fields.get(0); + assertEquals(field2.getElementName(), new String("ss")); + assertEquals(field2.getTypeName(), new String("int")); + if(field2.getVisibility() != IMember.V_PUBLIC) + fail("field visibility should be public!"); + + // typedefs + ArrayList nsTypeDefs = namespace.getChildrenOfType(ICElement.C_TYPEDEF); + ITypeDef td1 = (ITypeDef) nsTypeDefs.get(0); + assertEquals(td1.getElementName(), new String ("myStruct")); + assertEquals(td1.getTypeName(), new String ("struct MyStruct")); + ITypeDef td2 = (ITypeDef) nsTypeDefs.get(1); + assertEquals(td2.getElementName(), new String ("myTypedef")); + assertEquals(td2.getTypeName(), new String ("")); + + // union + ArrayList nsUnions = namespace.getChildrenOfType(ICElement.C_UNION); + IStructure u0 = (IStructure) nsUnions.get(0); + assertEquals(u0.getElementName(), new String("U")); + ArrayList u0Fields = u0.getChildrenOfType(ICElement.C_FIELD); + IField field3 = (IField) u0Fields.get(0); + assertEquals(field3.getElementName(), new String("U1")); + assertEquals(field3.getTypeName(), new String("int")); + if(field3.getVisibility() != IMember.V_PUBLIC) + fail("field visibility should be public!"); + } + + private void checkTemplates(IParent namespace){ + // template function + ArrayList functionTemplates = namespace.getChildrenOfType(ICElement.C_TEMPLATE_FUNCTION); + FunctionTemplate ft = (FunctionTemplate)functionTemplates.get(0); + assertEquals(ft.getElementName(), new String("aTemplatedFunction")); + assertEquals(ft.getTemplateSignature(), new String("aTemplatedFunction(B) : A")); + + // template method + ArrayList nsClasses = namespace.getChildrenOfType(ICElement.C_CLASS); + IStructure enclosingClass = (IStructure) nsClasses.get(1); + ArrayList methodTemplates = enclosingClass.getChildrenOfType(ICElement.C_TEMPLATE_METHOD); + MethodTemplate mt = (MethodTemplate)methodTemplates.get(0); + assertEquals(mt.getElementName(), new String("aTemplatedMethod")); + assertEquals(mt.getTemplateSignature(), new String("aTemplatedMethod(B) : A")); + assertEquals(mt.getVisibility(), IMember.V_PUBLIC); + + // template class + ArrayList classTemplates = namespace.getChildrenOfType(ICElement.C_TEMPLATE_CLASS); + ClassTemplate ct = (ClassTemplate)classTemplates.get(0); + assertEquals(ct.getElementName(), new String("myarray")); + assertEquals(ct.getTemplateSignature(), new String("myarray")); + } + + private void checkArrays(IParent tu){ + // array variable + ArrayList variables = tu.getChildrenOfType(ICElement.C_VARIABLE); + IVariable arrayVar = (IVariable) variables.get(0); + assertEquals(arrayVar.getElementName(), new String("myArray")); + assertEquals(arrayVar.getTypeName(), new String("int[][]")); + + // array parameter in function main + ArrayList functions = tu.getChildrenOfType(ICElement.C_FUNCTION); + IFunction mainFunction = (IFunction) functions.get(0); + assertEquals(mainFunction.getElementName(), new String("main")); + assertEquals(mainFunction.getReturnType(), new String("int")); + int NumOfParam = mainFunction.getNumberOfParameters(); + if(NumOfParam != 2) + fail("main should have two parameter!"); + String[] paramTypes = mainFunction.getParameterTypes(); + assertEquals(paramTypes[0], new String("int")); + assertEquals(paramTypes[1], new String("char*[]")); + + } + + } diff --git a/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/ElementDeltaTests.java b/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/ElementDeltaTests.java index e05d2a066eb..c5c3ad96edd 100644 --- a/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/ElementDeltaTests.java +++ b/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/ElementDeltaTests.java @@ -20,6 +20,7 @@ import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestSuite; +import org.eclipse.cdt.core.CCProjectNature; import org.eclipse.cdt.core.CCorePlugin; import org.eclipse.cdt.core.model.CModelException; import org.eclipse.cdt.core.model.ElementChangedEvent; @@ -35,7 +36,10 @@ import org.eclipse.cdt.internal.core.model.TranslationUnit; import org.eclipse.cdt.testplugin.CProjectHelper; import org.eclipse.cdt.testplugin.TestPluginLauncher; import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IProjectDescription; import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.NullProgressMonitor; import org.eclipse.core.runtime.Path; @@ -79,6 +83,9 @@ public class ElementDeltaTests extends TestCase implements IElementChangedListen e.printStackTrace(); } } + if (!fCProject.getProject().hasNature(CCProjectNature.CC_NATURE_ID)) { + addNatureToProject(fCProject.getProject(), CCProjectNature.CC_NATURE_ID, null); + } // register with the model manager to listen to delta changes CModelManager.getDefault().addElementChangedListener(this); @@ -87,6 +94,15 @@ public class ElementDeltaTests extends TestCase implements IElementChangedListen changedElements = new Vector(100); CCorePlugin.getDefault().setUseNewParser(true); } + private static void addNatureToProject(IProject proj, String natureId, IProgressMonitor monitor) throws CoreException { + IProjectDescription description = proj.getDescription(); + String[] prevNatures= description.getNatureIds(); + String[] newNatures= new String[prevNatures.length + 1]; + System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length); + newNatures[prevNatures.length]= natureId; + description.setNatureIds(newNatures); + proj.setDescription(description, monitor); + } protected void tearDown() throws Exception { CProjectHelper.delete(fCProject); diff --git a/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/WorkingCopyTests.java b/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/WorkingCopyTests.java index ca56cd87436..e5ba36a0b89 100644 --- a/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/WorkingCopyTests.java +++ b/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/WorkingCopyTests.java @@ -17,6 +17,8 @@ import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestSuite; +import org.eclipse.cdt.core.CCProjectNature; +import org.eclipse.cdt.core.CCorePlugin; import org.eclipse.cdt.core.model.IBuffer; import org.eclipse.cdt.core.model.ICProject; import org.eclipse.cdt.core.model.ITranslationUnit; @@ -25,7 +27,10 @@ import org.eclipse.cdt.internal.core.model.TranslationUnit; import org.eclipse.cdt.testplugin.CProjectHelper; import org.eclipse.cdt.testplugin.TestPluginLauncher; import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IProjectDescription; import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.NullProgressMonitor; import org.eclipse.core.runtime.Path; @@ -68,6 +73,20 @@ public class WorkingCopyTests extends TestCase { e.printStackTrace(); } } + if (!fCProject.getProject().hasNature(CCProjectNature.CC_NATURE_ID)) { + addNatureToProject(fCProject.getProject(), CCProjectNature.CC_NATURE_ID, null); + } + + CCorePlugin.getDefault().setUseNewParser(true); + } + private static void addNatureToProject(IProject proj, String natureId, IProgressMonitor monitor) throws CoreException { + IProjectDescription description = proj.getDescription(); + String[] prevNatures= description.getNatureIds(); + String[] newNatures= new String[prevNatures.length + 1]; + System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length); + newNatures[prevNatures.length]= natureId; + description.setNatureIds(newNatures); + proj.setDescription(description, monitor); } protected void tearDown() throws Exception { diff --git a/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/resources/cfiles/CModelElementsTestStart.h b/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/resources/cfiles/CModelElementsTestStart.h index 7c82da3c94b..5348d1063b0 100644 --- a/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/resources/cfiles/CModelElementsTestStart.h +++ b/core/org.eclipse.cdt.ui.tests/model/org/eclipse/cdt/core/model/tests/resources/cfiles/CModelElementsTestStart.h @@ -1,11 +1,118 @@ +// include #include -namespace MyPackage{ - class Hello{ +// macro +#define PRINT(string,msg) printf(string, msg) + +//namespace +namespace MyPackage +{ + // check class + // class + class Hello + { + // protected visibility protected: + // field int x; - void setX(int X){ + // method + inline void setX(int X) + { x = X; }; + // check nested pachage + // nested namespace + namespace MyNestedPackage { + // check parent nested class + // nested class + class Y + { // public visibility + public: + // constructor + Y(); + // virtual destructor + virtual ~Y(); + }; + // check derived nested class + // derived class + class X : public Y { + // private visibility + private: + // private field + B b; + + public: + // constructor chain + X(int x) : yy(x) { + cout << "In consturctor\n"; + } + // method declaration + int doNothing(); + }; + } }; -}; \ No newline at end of file + + // check enums + // enum without name + enum { first, second, third }; + // enum with name + enum MyEnum { f, s, t }; + + // check variables + // variable + int v; + // unsigned long variable + unsigned long vuLong; + // unsigned short variable + unsigned short vuShort; + + // check variable declarations + // variable declaration + extern int evar; + // function pointer + static void * (*orig_malloc_hook)(const char *file, int line, size_t size); + + // check functions + // simple function declaration + void foo(); + // function declaration with parameters + char* foo(int& x, char**y); + // simple function definition + void boo(){ + int g = 0; + }; + + // check Structs + // struct + struct MyStruct{ + int sint; + }; + // typedef and elaborated types + typedef struct MyStruct myStruct; + // typedef + typedef struct{ int ss; } myTypedef; + // unions + union U{ + int U1; + }; + + + // check templates + // template function + template A aTemplatedFunction( B bInstance ); + // template method + class enclosing { + // public visibility + public: + template A aTemplatedMethod( B bInstance ); + }; + // template class + template class myarray { /* */ }; +}; + + // check arrays + // arrays + int myArray [5][]; + int main(int argc, char * argv[]) { } + +