Fixed 1 test

cpg-language-cxx/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/cxx/CXXDeclarationTest.kt

@@ -25,11 +25,18 @@
  */
 package de.fraunhofer.aisec.cpg.frontends.cxx
 
+import de.fraunhofer.aisec.cpg.TestUtils
 import de.fraunhofer.aisec.cpg.TestUtils.analyze
+import de.fraunhofer.aisec.cpg.assertLocalName
+import de.fraunhofer.aisec.cpg.graph.declarations.FunctionDeclaration
 import de.fraunhofer.aisec.cpg.graph.declarations.TranslationUnitDeclaration
+import de.fraunhofer.aisec.cpg.graph.functions
+import de.fraunhofer.aisec.cpg.graph.get
+import de.fraunhofer.aisec.cpg.graph.statements.ReturnStatement
+import de.fraunhofer.aisec.cpg.graph.statements.expressions.Block
+import de.fraunhofer.aisec.cpg.graph.types.FunctionPointerType
 import java.io.File
-import kotlin.test.Test
-import kotlin.test.assertNotNull
+import kotlin.test.*
 
 class CXXDeclarationTest {
     @Test
@@ -52,4 +59,105 @@ class CXXDeclarationTest {
             }
         assertNotNull(typedef)
     }
+
+
+    @Test
+    fun testDefinitionDeclaration() {
+        val file = File("src/test/resources/cxx/definition.cpp")
+        val result =
+            analyze(listOf(file), file.parentFile.toPath(), true) {
+                it.registerLanguage<CPPLanguage>()
+            }
+        assertNotNull(result)
+
+        val declaration = result.functions[{ it.name.localName == "function" && !it.isDefinition }]
+        assertNotNull(declaration)
+
+        val definition = result.functions[{ it.name.localName == "function" && it.isDefinition }]
+        assertNotNull(definition)
+
+        assertEquals(definition, declaration.definition)
+    }
+
+    @Test
+    @Throws(Exception::class)
+    fun testFunctionDeclaration() {
+        val file = File("src/test/resources/cxx/functiondecl.cpp")
+        val tu =
+            TestUtils.analyzeAndGetFirstTU(listOf(file), file.parentFile.toPath(), true) {
+                it.registerLanguage<CPPLanguage>()
+            }
+
+        // should be eight function nodes
+        assertEquals(8, tu.functions.size)
+
+        var method = tu.getDeclarationAs(0, FunctionDeclaration::class.java)
+        assertEquals("function0(int)void", method!!.signature)
+
+        method = tu.getDeclarationAs(1, FunctionDeclaration::class.java)
+        assertEquals("function1(int, std::string, SomeType*, AnotherType&)int", method!!.signature)
+
+        val args = method.parameters.map { it.name.localName }
+        assertEquals(listOf("arg0", "arg1", "arg2", "arg3"), args)
+
+        val function0 = tu.functions[{ it.name.localName == "function0" && it.isDefinition }]
+        assertNotNull(function0)
+
+        val function0DeclOnly =
+            tu.functions[{ it.name.localName == "function0" && !it.isDefinition }]
+        assertNotNull(function0DeclOnly)
+
+        // the declaration should be connected to the definition
+        assertEquals(function0, function0DeclOnly.definition)
+
+        method = tu.getDeclarationAs(2, FunctionDeclaration::class.java)
+        assertEquals("function0(int)void", method!!.signature)
+
+        var statements = (method.body as Block).statements
+        assertFalse(statements.isEmpty())
+        assertEquals(2, statements.size)
+
+        // last statement should be an implicit return
+        var statement = method.getBodyStatementAs(statements.size - 1, ReturnStatement::class.java)
+        assertNotNull(statement)
+        assertTrue(statement.isImplicit)
+
+        method = tu.getDeclarationAs(3, FunctionDeclaration::class.java)
+        assertEquals("function2()void*", method!!.signature)
+
+        statements = (method.body as Block).statements
+        assertFalse(statements.isEmpty())
+        assertEquals(1, statements.size)
+
+        // should only contain 1 explicit return statement
+        statement = method.getBodyStatementAs(0, ReturnStatement::class.java)
+        assertNotNull(statement)
+        assertFalse(statement.isImplicit)
+
+        method = tu.getDeclarationAs(4, FunctionDeclaration::class.java)
+        assertNotNull(method)
+        assertEquals("function3()UnknownType*", method.signature)
+
+        method = tu.getDeclarationAs(5, FunctionDeclaration::class.java)
+        assertNotNull(method)
+        assertEquals("function4(int)void", method.signature)
+
+        method = tu.getDeclarationAs(6, FunctionDeclaration::class.java)
+        assertNotNull(method)
+        assertEquals(0, method.parameters.size)
+        assertEquals("function5()void", method.signature)
+
+        method = tu.getDeclarationAs(7, FunctionDeclaration::class.java)
+        assertNotNull(method)
+        assertEquals(1, method.parameters.size)
+
+        val param = method.parameters.firstOrNull()
+        assertNotNull(param)
+
+        val fpType = param.type as? FunctionPointerType
+        assertNotNull(fpType)
+        assertEquals(1, fpType.parameters.size)
+        assertLocalName("void", fpType.returnType)
+    }
+
 }

cpg-language-cxx/src/test/resources/cxx/typedef_in_class.cpp

@@ -0,0 +1,23 @@
+class SomeDataClass {
+public:
+    int doOperation();
+};
+
+class MyClass {
+private:
+    // This typedef is FQN'd to MyClass::Data, but it cannot be accessed
+    // outside of the class because it is declared as private (however we
+    // are not yet using visibility information).
+    typedef SomeDataClass Data;
+
+    Data *d;
+
+public:
+    MyClass() {
+        d = new Data();
+    }
+
+    int myFunction() {
+        return d->doOperation();
+    }
+};