initial commit for github

2019-12-12 14:41:47 +01:00 · 2019-12-12 14:41:47 +01:00 · 60968612de
commit 60968612de
370 changed files with 68427 additions and 0 deletions
--- a/test/headerrepresentation/src/tester_headerrepresentation.cpp
+++ b/test/headerrepresentation/src/tester_headerrepresentation.cpp
@ -0,0 +1,956 @@
+/**
+ *
+ * Test functions for <template>
+ *
+ * @file
+ * Copyright &copy; Audi Electronics Venture GmbH. All rights reserved
+ *
+ * $Author$
+ * $Date$
+ * $Revision$
+ *
+ * @remarks
+ *
+ */
+
+#include <ddl.h>
+#include <gtest/gtest.h>
+#include "../../_common/adtf_compat.h"
+#include "../../_common/compat.h"
+#include "ddl_definitions.h"
+#include "header_importer.h"
+#include "header_header.h"
+#include "header_printer.h"
+#include "header_to_ddl_converter.h"
+#include "ddl_to_header_converter.h"
+
+using namespace ddl;
+#ifdef WIN32
+#pragma warning(disable : 4355) // 'this' used in initializer list
+#endif
+
+#define LOG_POS LOG_INFO(a_util::strings::format("Starting Test '%s' (Line %d)", __FUNCTION__, __LINE__).c_str());
+
+HeaderTypesVec* m_pVecADTFTypes;
+
+const ddl::HeaderType* getType(const char* strName)
+{
+    for (ddl::HeaderTypesVec::const_iterator pIter = m_pVecADTFTypes->begin(); pIter != m_pVecADTFTypes->end(); pIter++)
+    {
+        if ((*pIter)->getName().compare(strName) == 0)
+        {
+            return (*pIter);
+        }
+    }
+    return NULL;
+}
+
+void TestHeader(ddl::Header* pHeader, const char* strName, size_t szStructs, size_t szTypedefs, size_t szConstants)
+{
+    ASSERT_TRUE(pHeader);
+    ASSERT_TRUE(pHeader->getName().compare(strName) == 0);
+    ASSERT_TRUE(pHeader->getStructs().size() == szStructs);
+    ASSERT_TRUE(pHeader->getTypedefs().size() == szTypedefs);
+    ASSERT_TRUE(pHeader->getConstants().size() == szConstants);
+}
+
+void TestStruct(Header* pHeader, size_t szStructIndex, size_t szElements, bool bCanContainMoreElements /* = false */)
+{
+    ASSERT_TRUE(pHeader);
+    ASSERT_TRUE(pHeader->getStructs().size() > szStructIndex);
+    HeaderStruct* pStruct = pHeader->getStructs()[szStructIndex];
+    ASSERT_TRUE(pStruct);
+    if (bCanContainMoreElements)
+    {
+        ASSERT_TRUE(pStruct->getElements().size() >= szElements);
+    }
+    else
+    {
+        ASSERT_TRUE(pStruct->getElements().size() == szElements);
+    }
+}
+
+
+void TestStruct(Header* pHeader, size_t szStructIndex, size_t szElements, const char* strName, size_t szPacking, bool bCanContainMoreElements = false)
+{
+    TestStruct(pHeader, szStructIndex, szElements, bCanContainMoreElements);
+    ASSERT_TRUE(pHeader->getStructs().size() > 0);
+    HeaderStruct* pStruct = pHeader->getStructs()[szStructIndex];
+    ASSERT_TRUE(pStruct->getName().compare(strName) == 0);
+    size_t test = pStruct->getPacking();
+    size_t test2 = szPacking;
+    ASSERT_TRUE(pStruct->getPacking() == szPacking);
+}
+
+void TestStructElement(Header* pHeader, size_t szStructIndex, size_t szElementIndex, const HeaderType *pType, const char* strName, size_t szArraySize)
+{
+    TestStruct(pHeader, szStructIndex, szElementIndex, true);
+    ASSERT_TRUE(pHeader->getStructs().size() > 0);
+    HeaderStruct* pStruct = pHeader->getStructs()[szStructIndex];
+    HeaderStructElement* pElement = pStruct->getElements()[szElementIndex];
+    ASSERT_TRUE(pElement);
+    ASSERT_TRUE(pElement->getType() == pType);
+    ASSERT_TRUE(pElement->getName().compare(strName) == 0);
+    ASSERT_TRUE(pElement->getArraySize() == szArraySize);
+}
+
+void TestTypedef(Header* pHeader, size_t szTypedefIndex, const HeaderType* pOriginalType, const char* strName, size_t szPacking)
+{
+    ASSERT_TRUE(pHeader);
+    ASSERT_TRUE(pHeader->getTypedefs().size() > szTypedefIndex);
+    HeaderTypedef* pTypedef = pHeader->getTypedefs()[szTypedefIndex];
+    ASSERT_TRUE(pTypedef);
+    ASSERT_TRUE(pTypedef->getOriginalType() == pOriginalType);
+    ASSERT_TRUE(pTypedef->getName().compare(strName) == 0);
+    ASSERT_TRUE(pTypedef->getPacking() == szPacking);
+}
+
+void TestConstant(Header* pHeader, size_t szConstantIndex, const HeaderType* pType, int64_t i64Value, const char* strName)
+{
+    ASSERT_TRUE(pHeader);
+    ASSERT_TRUE(pHeader->getConstants().size() > szConstantIndex);
+    HeaderConstant* pConstant = pHeader->getConstants()[szConstantIndex];
+    ASSERT_TRUE(pConstant);
+    ASSERT_TRUE(pConstant->getName().compare(strName) == 0);
+    ASSERT_TRUE(pConstant->getType() == pType);
+    ASSERT_TRUE(pConstant->asInt64() == i64Value);
+}
+
+void TestDDL(DDLDescription* pDescription, const a_util::filesystem::Path &oReferenceFile)
+{
+    DDLPrinter oPrinter;
+    pDescription->accept(&oPrinter);
+    std::string strXML = oPrinter.getXML();
+    ASSERT_TRUE(strXML.find("description") != std::string::npos);
+    ASSERT_TRUE(pDescription->getHeader()->getLanguageVersion() == ddl::DDLVersion::ddl_version_40);
+    ASSERT_TRUE(pDescription->getBaseunits().size() > 0);
+    ASSERT_TRUE(pDescription->getDatatypes().size() > 0);
+}
+
+
+
+void test_set_up()
+{
+    m_pVecADTFTypes = HeaderImporter::getDefaultTypes();
+}
+
+void test_tear_down()
+{
+    if (m_pVecADTFTypes)
+    {
+        for (HeaderTypesVec::iterator pIter = m_pVecADTFTypes->begin(); pIter != m_pVecADTFTypes->end(); pIter++)
+        {
+            delete *pIter;
+        }
+        delete m_pVecADTFTypes;
+        m_pVecADTFTypes = NULL;
+    }
+}
+
+struct Testinitializer
+{
+    Testinitializer()
+    {
+        test_set_up();
+    }
+    ~Testinitializer()
+    {
+        test_tear_down();
+    }
+};
+
+/**
+* @detail This test makes sure that basic structures can be read.
+*/
+TEST(cTesterHeaderRepresentation,
+    SimpleHeaders)
+{
+    TEST_REQ("");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS, oHeaderImporter.setFileName("files/simple_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS, oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS, oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+
+    TestHeader(pHeader, "simple_header.h", 3, 1, 0);
+
+    TestStruct(pHeader, 0, 1, "simple_struct1", getType("uint8_t")->getPacking());
+    TestStructElement(pHeader, 0, 0, getType("uint8_t"), "a", 1);
+
+    TestStruct(pHeader, 1, 1, "simple_struct2", getType("tUInt16")->getPacking());
+    TestStructElement(pHeader, 1, 0, getType("tUInt16"), "b", 1);
+
+    TestStruct(pHeader, 2, 1, "simple_struct3", getType("unsigned int")->getPacking());
+    TestStructElement(pHeader, 2, 0, getType("unsigned int"), "c", 1);
+
+    if (pHeader->getStructs().size() >= 2)
+    {
+        TestTypedef(pHeader, 0, pHeader->getStructs()[2], "simple_struct4", pHeader->getStructs()[2]->getPacking());
+    }
+    
+    delete pHeader;
+    TearDown();
+}
+
+/**
+* @detail This test makes sure typedefs can be read.
+*/
+TEST(cTesterHeaderRepresentation,
+    Typedefs)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS, oHeaderImporter.setFileName("files/typedef_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS, oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS, oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+
+    TestHeader(pHeader, "typedef_header.h", 0, 5, 0);
+
+    TestTypedef(pHeader, 0, getType("tUInt32"), "UINT_32", getType("tUInt32")->getPacking());
+    TestTypedef(pHeader, 1, getType("tUInt16"), "UINT_16", getType("tUInt16")->getPacking());
+    TestTypedef(pHeader, 2, getType("tUInt64"), "UINT_64", getType("tUInt64")->getPacking());
+
+    if (pHeader->getTypedefs().size() >= 3)
+    {
+        TestTypedef(pHeader, 3, pHeader->getTypedefs()[2], "uint64", getType("tUInt64")->getPacking());
+        TestTypedef(pHeader, 4, pHeader->getTypedefs()[3], "supergross", getType("tUInt64")->getPacking());
+    }
+    delete pHeader;
+}
+
+/**
+* @detail This test makes sure that constants can be read.
+*/
+TEST(cTesterHeaderRepresentation,
+    Constants)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/constants_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+
+    TestHeader(pHeader, "constants_header.h", 0, 0, 2);
+
+    TestConstant(pHeader, 0, getType("tInt16"), 42, "d");
+    TestConstant(pHeader, 1, getType("tInt32"), 43, "e");
+    delete pHeader;
+}
+
+/**
+* @detail This test makes sure that defines can be read.
+*/
+TEST(cTesterHeaderRepresentation,
+    Defines)
+{
+    TEST_REQ("ACORE-6822, ACORE-7188");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/defines_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+
+    TestHeader(pHeader, "defines_header.h", 0, 0, 7);
+    TestConstant(pHeader, 0, getType("tUInt64"), 5, "FIRST_CONSTANT");
+    TestConstant(pHeader, 1, getType("tUInt64"), 6, "OTHER_CONSTANT");
+    TestConstant(pHeader, 2, getType("tUInt64"), 7, "LAST_CONSTANT");
+    TestConstant(pHeader, 3, getType("tUInt64"), 32, "RDB_SIZE_OBJECT_NAME");
+    TestConstant(pHeader, 4, getType("tUInt64"), 64, "RDB_SIZE_SCP_NAME");
+    TestConstant(pHeader, 5, getType("tUInt64"), 1024, "RDB_SIZE_FILENAME");
+    TestConstant(pHeader, 6, getType("tUInt64"), 8, "RDB_SIZE_TRLIGHT_PHASES");
+
+    delete pHeader;
+
+    // Now check if a explicitly set default type is used
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setDefaultIntegerType(getType("tUInt32")));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    pHeader = oHeaderImporter.getHeader();    
+
+    TestHeader(pHeader, "defines_header.h", 0, 0, 7);
+    TestConstant(pHeader, 0, getType("tUInt32"), 5, "FIRST_CONSTANT");
+    TestConstant(pHeader, 1, getType("tUInt32"), 6, "OTHER_CONSTANT");
+    TestConstant(pHeader, 2, getType("tUInt32"), 7, "LAST_CONSTANT");
+    TestConstant(pHeader, 3, getType("tUInt32"), 32, "RDB_SIZE_OBJECT_NAME");
+    TestConstant(pHeader, 4, getType("tUInt32"), 64, "RDB_SIZE_SCP_NAME");
+    TestConstant(pHeader, 5, getType("tUInt32"), 1024, "RDB_SIZE_FILENAME");
+    TestConstant(pHeader, 6, getType("tUInt32"), 8, "RDB_SIZE_TRLIGHT_PHASES");
+    delete pHeader;
+}
+
+/**
+* @detail This test makes sure that wrong structures, typedefs and defines not parsed.
+*/
+TEST(cTesterHeaderRepresentation,
+    FaultyHeader)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    // Correct defines will be ignored
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/faulty_header1.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    TestHeader(pHeader, "faulty_header1.h", 0, 0, 0);
+    delete pHeader;
+
+    // Unnamed struct
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/faulty_header2.h"));
+    ASSERT_NE(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    pHeader = oHeaderImporter.getHeader();
+    delete pHeader;
+
+    // Member has unknown type
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/faulty_header3.h"));
+    ASSERT_NE(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    pHeader = oHeaderImporter.getHeader();
+    delete pHeader;
+
+    // Unnamed struct
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/faulty_header4.h"));
+    ASSERT_NE(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    pHeader = oHeaderImporter.getHeader();
+    delete pHeader;
+
+    // Weird typedefs
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/faulty_header5.h"));
+    ASSERT_NE(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    pHeader = oHeaderImporter.getHeader();
+    delete pHeader;
+}
+
+/**
+* @detail This test makes sure that wrong settings will lead to structures, 
+* typedefs and defines not being parsed.
+*/
+TEST(cTesterHeaderRepresentation,
+    FaultySettings)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    // Test if define will not be parsed when no default type is set and tUInt64 is not a known type
+    // Remove tUInt64 from known types
+    for (ddl::HeaderTypesVec::iterator pIter = m_pVecADTFTypes->begin(); pIter != m_pVecADTFTypes->end(); pIter++)
+    {
+        if ((*pIter)->getName().compare("tUInt64") == 0)
+        {
+            delete *pIter;
+            m_pVecADTFTypes->erase(pIter);
+            break;
+        }
+    }
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/defines_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setDefaultIntegerType(NULL));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    TestHeader(pHeader, "defines_header.h", 0, 0, 0);
+    delete pHeader;
+    // Check importer with faulty filename
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/does_not_exist_header.h"));
+    ASSERT_TRUE(a_util::result::isFailed(oHeaderImporter.createNew()));
+}
+
+/**
+* @detail This test makes sure that comments in and around structures, 
+* typedefs and defines will be ignored and everything is parsed successfully.
+*/
+TEST(cTesterHeaderRepresentation,
+    CommentedHeader)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/commented_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    TestHeader(pHeader, "commented_header.h", 3, 3, 3);
+
+    //Check structures
+    TestStruct(pHeader, 0, 1, "simple_struct1", getType("tUInt8")->getPacking());
+    TestStructElement(pHeader, 0, 0, getType("tUInt8"), "a", 1);
+
+    TestStruct(pHeader, 1, 1, "simple_struct2", getType("tUInt16")->getPacking());
+    TestStructElement(pHeader, 1, 0, getType("tUInt16"), "b", 1);
+
+    TestStruct(pHeader, 2, 1, "simple_struct3", getType("tUInt32")->getPacking());
+    TestStructElement(pHeader, 2, 0, getType("tUInt32"), "c", 1);
+
+    // Check typedefs
+    TestTypedef(pHeader, 0,  getType("tUInt32"), "UINT_32", getType("tUInt32")->getPacking());
+    TestTypedef(pHeader, 1,  getType("tUInt16"), "UINT_16", getType("tUInt16")->getPacking());
+    if (pHeader->getStructs().size() >= 2)
+    {
+        TestTypedef(pHeader, 2, pHeader->getStructs()[2], "simple_struct4", pHeader->getStructs()[2]->getPacking());
+    }
+
+    // Check constants
+    TestConstant(pHeader, 0, getType("tInt16"), 42, "d");
+    TestConstant(pHeader, 1, getType("tInt32"), 43, "e");
+    TestConstant(pHeader, 2, getType("tUInt64"), 6, "constant1");
+    delete pHeader;
+}
+
+/**
+* @detail This test makes sure that complex (nested) structures can be parsed successfully.
+*/
+TEST(cTesterHeaderRepresentation,
+    ComplexStructs)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/complex_header.h"));
+    ASSERT_TRUE(a_util::result::isOk(oHeaderImporter.setKnownTypes(m_pVecADTFTypes)));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setDefaultIntegerType(NULL));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+
+    TestHeader(pHeader, "complex_header.h", 5, 1, 0);
+
+    TestStruct(pHeader, 0, 1, "simple_struct1", getType("tUInt8")->getPacking());
+    TestStructElement(pHeader, 0, 0, getType("tUInt8"), "a", 1);
+
+    TestStruct(pHeader, 1, 1, "simple_struct2", getType("tUInt16")->getPacking());
+    TestStructElement(pHeader, 1, 0, getType("tUInt16"), "b", 1);
+
+    TestStruct(pHeader, 2, 1, "simple_struct3", getType("tUInt32")->getPacking());
+    TestStructElement(pHeader, 2, 0, getType("tUInt32"), "c", 1);
+
+    if (pHeader->getStructs().size() >= 2)
+    {
+        TestStruct(pHeader, 3, 3, "complex_struct1", pHeader->getStructs()[2]->getPacking());
+        TestStructElement(pHeader, 3, 0, getType("tUInt16"), "a", 1);
+        TestStructElement(pHeader, 3, 1, pHeader->getStructs()[0], "b", 1);
+        TestStructElement(pHeader, 3, 2, pHeader->getStructs()[2], "c", 1);
+
+        TestStruct(pHeader, 4, 3, "complex_struct2", pHeader->getStructs()[2]->getPacking());
+        TestStructElement(pHeader, 4, 0, pHeader->getStructs()[0], "d", 1);
+        TestStructElement(pHeader, 4, 1, pHeader->getStructs()[2], "e", 1);
+        TestStructElement(pHeader, 4, 2, pHeader->getStructs()[3], "f", 1);
+
+        TestTypedef(pHeader, 0, pHeader->getStructs()[2], "simple_struct4", pHeader->getStructs()[2]->getPacking());
+    }
+    delete pHeader;
+}
+
+/**
+* @detail This test makes sure that structures containing array elements can be parsed successfully.
+*/
+TEST(cTesterHeaderRepresentation,
+    ArrayStructs)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/array_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setDefaultIntegerType(NULL));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+
+    TestHeader(pHeader, "array_header.h", 4, 0, 2);
+    TestConstant(pHeader, 0, getType("tUInt64"), 8, "count1");
+    TestConstant(pHeader, 1, getType("tUInt8"), 9, "count2");
+
+    TestStruct(pHeader, 0, 1, "simple_array_struct", getType("tUInt8")->getPacking());
+    TestStructElement(pHeader, 0, 0, getType("tUInt8"), "a", 5);
+
+    TestStruct(pHeader, 1, 1, "simple_struct1", getType("tUInt8")->getPacking());
+    TestStructElement(pHeader, 1, 0, getType("tUInt8"), "b", 1);
+
+    TestStruct(pHeader, 2, 5, "complex_array_struct1", getType("tUInt8")->getPacking());
+    TestStructElement(pHeader, 2, 0, getType("tUInt8"), "c", 1);
+
+    if (pHeader->getStructs().size() >= 1)
+    {
+        TestStructElement(pHeader, 2, 1, pHeader->getStructs()[1], "d", 1);
+        TestStructElement(pHeader, 2, 2, pHeader->getStructs()[0], "f", 1);
+        TestStructElement(pHeader, 2, 3, pHeader->getStructs()[1], "g", 6);
+        TestStructElement(pHeader, 2, 4, pHeader->getStructs()[0], "h", 7);
+
+        TestStruct(pHeader, 3, 5, "complex_array_struct2", getType("tUInt8")->getPacking());
+        TestStructElement(pHeader, 3, 0, getType("tUInt8"), "i", 8);
+        TestStructElement(pHeader, 3, 1, pHeader->getStructs()[1], "j", 1);
+        TestStructElement(pHeader, 3, 2, pHeader->getStructs()[0], "k", 1);
+        TestStructElement(pHeader, 3, 3, pHeader->getStructs()[1], "l", 9);
+        TestStructElement(pHeader, 3, 4, pHeader->getStructs()[0], "m", 10);
+    }
+    delete pHeader;
+}
+
+/**
+* @detail This test makes sure that the packing information stated by #pragma pack can be parsed successfully.
+*/
+TEST(cTesterHeaderRepresentation,
+    StructsPacking)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/packing_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setDefaultIntegerType(NULL));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+
+    TestHeader(pHeader, "packing_header.h", 5, 1, 0);
+
+    TestStruct(pHeader, 0, 1, "simple_struct1", getType("tUInt8")->getPacking());
+    TestStructElement(pHeader, 0, 0, getType("tUInt8"), "a", 1);
+
+    TestStruct(pHeader, 1, 1, "simple_struct2", 1);
+    TestStructElement(pHeader, 1, 0, getType("tUInt16"), "b", 1);
+
+    TestStruct(pHeader, 2, 1, "simple_struct3", 2);
+    TestStructElement(pHeader, 2, 0, getType("tUInt32"), "c", 1);
+
+    TestStruct(pHeader, 3, 1, "simple_struct5", 2);
+    TestStructElement(pHeader, 3, 0, getType("tUInt64"), "d", 1);
+
+    TestStruct(pHeader, 4, 1, "simple_struct6", 1);
+    TestStructElement(pHeader, 4, 0, getType("tUInt64"), "e", 1);
+
+    if (pHeader->getStructs().size() >= 2)
+    {
+        TestTypedef(pHeader, 0, pHeader->getStructs()[2], "simple_struct4", pHeader->getStructs()[2]->getPacking());
+    }
+    delete pHeader;
+}
+
+/**
+* @detail This test makes sure that a simple header can be printed.
+*/
+TEST(cTesterHeaderRepresentation,
+    PrintSimpleHeaders)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/simple_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    HeaderPrinter oPrinter;
+    pHeader->accept(&oPrinter);
+    std::string strExpected;
+    a_util::filesystem::readTextFile(a_util::filesystem::Path("files/simple_header_expected.h"), strExpected);
+    strExpected.erase(std::remove(strExpected.begin(), strExpected.end(), '\r'), strExpected.end());
+    std::string test = oPrinter.getHeader();
+    ASSERT_TRUE(strExpected.compare(oPrinter.getHeader()) == 0);
+    delete pHeader;
+}
+
+/**
+* @detail This test makes sure that a complex header can be printed.
+*/
+TEST(cTesterHeaderRepresentation,
+    PrintComplexStructs)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/complex_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    HeaderPrinter oPrinter;
+    pHeader->accept(&oPrinter);
+    std::string strExpected;
+    a_util::filesystem::readTextFile(a_util::filesystem::Path("files/complex_header_expected.h"), strExpected);
+    strExpected.erase(std::remove(strExpected.begin(), strExpected.end(), '\r'), strExpected.end());
+    ASSERT_TRUE(strExpected.compare(oPrinter.getHeader()) == 0);
+    delete pHeader;
+}
+
+/**
+* @detail This test makes sure that a header with arrays can be printed.
+*/
+TEST(cTesterHeaderRepresentation,
+    PrintArrayStructs)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/array_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    HeaderPrinter oPrinter;
+    pHeader->accept(&oPrinter);
+    std::string strExpected;
+    a_util::filesystem::readTextFile(a_util::filesystem::Path("files/array_header_expected.h"), strExpected);
+    strExpected.erase(std::remove(strExpected.begin(), strExpected.end(), '\r'), strExpected.end());
+    ASSERT_TRUE(strExpected.compare(oPrinter.getHeader()) == 0);
+    delete pHeader;
+}
+
+/**
+* @detail This test makes sure that a header with packing can be printed.
+*/
+TEST(cTesterHeaderRepresentation,
+    PrintPackingStructs)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/packing_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    HeaderPrinter oPrinter;
+    pHeader->accept(&oPrinter);
+    std::string strExpected;
+    a_util::filesystem::readTextFile(a_util::filesystem::Path("files/packing_header_expected.h"), strExpected);
+    strExpected.erase(std::remove(strExpected.begin(), strExpected.end(), '\r'), strExpected.end());
+    ASSERT_TRUE(strExpected.compare(oPrinter.getHeader()) == 0);
+    delete pHeader;
+}
+
+/**
+* @detail This test makes sure that a header with typedefs can be printed.
+*/
+TEST(cTesterHeaderRepresentation,
+    PrintTypedefs)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/typedef_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    HeaderPrinter oPrinter;
+    pHeader->accept(&oPrinter);
+    std::string strExpected;
+    a_util::filesystem::readTextFile(a_util::filesystem::Path("files/typedef_header_expected.h"), strExpected);
+    strExpected.erase(std::remove(strExpected.begin(), strExpected.end(), '\r'), strExpected.end());
+    ASSERT_TRUE(strExpected.compare(oPrinter.getHeader()) == 0);
+    delete pHeader;
+}
+
+/**
+* @detail This test makes sure that a simple header can be converted to DDL.
+*/
+TEST(cTesterHeaderRepresentation,
+    ConvertSimpleHeaderToDDL)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/simple_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    HeaderToDDLConverter oConverter;
+    pHeader->accept(&oConverter);
+    oConverter.createNew();
+    TestDDL(oConverter.getDDL(), a_util::filesystem::Path("files/simple_header_expected.description"));
+    
+    delete pHeader;
+    delete oConverter.getDDL();
+}
+
+/**
+* @detail This test makes sure that a complex header can be converted to DDL.
+*/
+TEST(cTesterHeaderRepresentation,
+    ConvertComplexHeaderToDDL)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/complex_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    HeaderToDDLConverter oConverter;
+    pHeader->accept(&oConverter);
+    oConverter.createNew();
+    TestDDL(oConverter.getDDL(), a_util::filesystem::Path("files/complex_header_expected.description"));
+
+    delete pHeader;
+    delete oConverter.getDDL();
+}
+
+/**
+* @detail This test makes sure that a header with array information can be converted to DDL.
+*/
+TEST(cTesterHeaderRepresentation,
+    ConvertArrayHeaderToDDL)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/array_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    HeaderToDDLConverter oConverter;
+    pHeader->accept(&oConverter);
+    oConverter.createNew();
+    TestDDL(oConverter.getDDL(), a_util::filesystem::Path("files/array_header_expected.description"));
+
+    delete pHeader;
+    delete oConverter.getDDL();
+}
+
+/**
+* @detail This test makes sure that a header with packing information can be converted to DDL.
+*/
+TEST(cTesterHeaderRepresentation,
+    ConvertPackingHeaderToDDL)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/packing_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    HeaderToDDLConverter oConverter;
+    pHeader->accept(&oConverter);
+    oConverter.createNew();
+    TestDDL(oConverter.getDDL(), a_util::filesystem::Path("files/packing_header_expected.description"));
+
+    delete pHeader;
+    delete oConverter.getDDL();
+}
+
+/**
+* @detail This test makes sure that a VTD RDB header with can be converted to DDL.
+*/
+TEST(cTesterHeaderRepresentation,
+    ConvertRDBHeaderToDDL)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/viRDBIcd.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    HeaderToDDLConverter oConverter;
+    pHeader->accept(&oConverter);
+    oConverter.createNew();
+    TestDDL(oConverter.getDDL(), a_util::filesystem::Path("files/viRDBIcd_expected.description"));
+
+    delete pHeader;
+    delete oConverter.getDDL();
+}
+
+/**
+* @detail This test makes sure that a single struct and its dependencies can be converted to DDL.
+*/
+TEST(cTesterHeaderRepresentation,
+    ConvertStructToDDL)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/complex_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    HeaderToDDLConverter oConverter;
+    TestHeader(pHeader, "complex_header.h", 5, 1, 0);
+    if (pHeader->getStructs().size() >= 4)
+    {
+        pHeader->getStructs()[4]->accept(&oConverter);
+    }
+    oConverter.createNew();
+    TestDDL(oConverter.getDDL(), a_util::filesystem::Path("files/complex_struct2_expected.description"));
+    delete pHeader;
+    delete oConverter.getDDL();
+}
+
+/**
+* @detail This test makes sure that multiple structures and its dependencies can be converted to DDL.
+*/
+TEST(cTesterHeaderRepresentation,
+    ConvertTwoStructsToDDL)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/viRDBIcd.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+    HeaderToDDLConverter oConverter;
+    TestHeader(pHeader, "viRDBIcd.h", 55, 0, 221);
+    if (pHeader->getStructs().size() >= 24)
+    {
+        pHeader->getStructs()[10]->accept(&oConverter);
+        pHeader->getStructs()[24]->accept(&oConverter);
+    }
+    oConverter.createNew();
+    TestDDL(oConverter.getDDL(), a_util::filesystem::Path("files/viRDBIcd_extract_expected.description"));
+    delete pHeader;
+    delete oConverter.getDDL();
+}
+
+/**
+* @detail This test makes sure that simple DDL structures can be converted to a header.
+*/
+TEST(cTesterHeaderRepresentation,
+    ConvertSimpleStructsToHeader)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    DDLImporter oImporter(true, false);
+    oImporter.setFile("files/adtf2.description");
+    oImporter.createNew();
+    DDLToHeaderConverter oConverter;
+    oConverter.setKnownTypes(m_pVecADTFTypes);
+    ASSERT_TRUE(oImporter.getDDL());
+    oImporter.getDDL()->accept(&oConverter);
+    oConverter.createNew();
+    oConverter.getHeader();
+    Header* pHeader = oConverter.getHeader();
+    HeaderPrinter oPrinter;
+    pHeader->accept(&oPrinter);
+    std::string strExpected;
+    a_util::filesystem::readTextFile(a_util::filesystem::Path("files/adtf_expected.h"), strExpected);
+    strExpected.erase(std::remove(strExpected.begin(), strExpected.end(), '\r'), strExpected.end());
+    ASSERT_TRUE(strExpected.compare(oPrinter.getHeader()) == 0);
+    delete pHeader;
+    oImporter.destroyDDL();
+}
+
+/**
+* @detail This test makes sure that complex DDL structures can be converted to a header.
+*/
+TEST(cTesterHeaderRepresentation,
+    ConvertComplexStructsToHeader)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    DDLImporter oImporter(true, false);
+    oImporter.setFile("files/viRDBIcd_expected.description");
+    oImporter.createNew();
+    DDLToHeaderConverter oConverter;
+    oConverter.setKnownTypes(m_pVecADTFTypes);
+    ASSERT_TRUE(oImporter.getDDL());
+    oImporter.getDDL()->accept(&oConverter);
+    oConverter.createNew();
+    oConverter.getHeader();
+    Header* pHeader = oConverter.getHeader();
+    HeaderPrinter oPrinter;
+    pHeader->accept(&oPrinter);
+    std::string strExpected;
+    a_util::filesystem::readTextFile(a_util::filesystem::Path("files/viRDBIcd_expected.h"), strExpected);
+    strExpected.erase(std::remove(strExpected.begin(), strExpected.end(), '\r'), strExpected.end());
+    ASSERT_TRUE(strExpected.compare(oPrinter.getHeader()) == 0);
+    delete pHeader;
+    oImporter.destroyDDL();
+}
+
+/**
+* @detail This test makes sure that selected DDL structures can be converted to a header.
+*/
+TEST(cTesterHeaderRepresentation,
+    ConvertTwoStructsToHeader)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    DDLImporter oImporter;
+    oImporter.setFile("files/viRDBIcd_expected.description");
+    oImporter.createNew();
+    DDLToHeaderConverter oConverter;
+    oConverter.setKnownTypes(m_pVecADTFTypes);
+    ASSERT_TRUE(oImporter.getDDL());
+    oImporter.getDDL()->getStructByName("RDB_DRIVETRAIN_t")->accept(&oConverter);
+    oImporter.getDDL()->getStructByName("RDB_SENSOR_STATE_t")->accept(&oConverter);
+    oConverter.createNew();
+    oConverter.getHeader();
+    Header* pHeader = oConverter.getHeader();
+    HeaderPrinter oPrinter;
+    pHeader->accept(&oPrinter);
+    std::string strExpected;
+    a_util::filesystem::readTextFile(a_util::filesystem::Path("files/viRDBIcd_extract_expected.h"), strExpected);
+    strExpected.erase(std::remove(strExpected.begin(), strExpected.end(), '\r'), strExpected.end());
+    ASSERT_TRUE(strExpected.compare(oPrinter.getHeader()) == 0);
+    delete pHeader;
+    oImporter.destroyDDL();
+}
+
+/**
+* @detail This test makes sure that the default types defined in the importer have the correct packing.
+*/
+TEST(cTesterHeaderRepresentation,
+    CheckDefaultTypes)
+{
+    TEST_REQ("ACORE-6822");
+
+    Testinitializer oTestSetup;
+    // Check default types
+#ifdef __ADTF_WIN32
+    ASSERT_TRUE(getType("float")->getPacking() == 8);
+#endif
+#ifdef __ADTF_WIN64
+    ASSERT_TRUE(getType("float")->getPacking() == 8);
+#endif
+#ifdef __ADTF_LINUX32
+    ASSERT_TRUE(getType("float")->getPacking() == 4);
+#endif
+#ifdef __ADTF_LINUX64
+    ASSERT_TRUE(getType("float")->getPacking() == 8);
+#endif
+    // Check default packing (no #pragma pack stated)
+    HeaderImporter oHeaderImporter;
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setFileName("files/default_types_header.h"));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.setKnownTypes(m_pVecADTFTypes));
+    ASSERT_EQ(a_util::result::SUCCESS,oHeaderImporter.createNew());
+    Header* pHeader = oHeaderImporter.getHeader();
+
+    TestHeader(pHeader, "default_types_header.h", 1, 0, 0);
+
+#ifdef __GNUC__
+    #ifdef __ADTF32
+        TestStruct(pHeader, 0, 2, "doubles", 4);
+    #endif
+    #ifdef __ADTF64
+        TestStruct(pHeader, 0, 2, "doubles", 8);
+    #endif
+#endif
+#ifdef _MSC_VER
+    TestStruct(pHeader, 0, 2, "doubles", getType("double")->getPacking());
+#endif
+    delete pHeader;
+}
+
+