modules/Internals/RegTests.pm

###########################################################################
# Module for ABI Compliance Checker with regression test suite
#
# Copyright (C) 2009-2011 Institute for System Programming, RAS
# Copyright (C) 2011-2012 Nokia Corporation and/or its subsidiary(-ies)
# Copyright (C) 2011-2012 ROSA Laboratory
# Copyright (C) 2012-2016 Andrey Ponomarenko's ABI Laboratory
#
# Written by Andrey Ponomarenko
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License or the GNU Lesser
# General Public License as published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# and the GNU Lesser General Public License along with this program.
# If not, see <http://www.gnu.org/licenses/>.
###########################################################################
use strict;

my ($TestDump, $Debug, $Quiet, $ExtendedCheck, $LogMode, $ReportFormat,
$DumpFormat, $LIB_EXT, $GCC_PATH, $SortDump, $CheckHeadersOnly,
$OldStyle, $TestABIDumper);
my $OSgroup = get_OSgroup();

sub testTool($$$$$$$$$$$)
{
    ($TestDump, $Debug, $Quiet, $ExtendedCheck, $LogMode, $ReportFormat,
    $DumpFormat, $LIB_EXT, $GCC_PATH, $SortDump, $CheckHeadersOnly,
    $OldStyle, $TestABIDumper) = @_;

    testC();
    testCpp();
}

sub testCpp()
{
    printMsg("INFO", "verifying detectable C++ library changes");
    my ($HEADER1, $SOURCE1, $HEADER2, $SOURCE2) = ();
    my $DECL_SPEC = ($OSgroup eq "windows")?"__declspec( dllexport )":"";
    my $EXTERN = ($OSgroup eq "windows")?"extern ":""; # add "extern" for CL compiler

    # Class outside namespace
    $HEADER1 .= "
        class $DECL_SPEC OutsideNS {
        public:
            int someMethod();
            int field;
        };";
    $SOURCE1 .= "
        int OutsideNS::someMethod() { return 0; }";

    $HEADER2 .= "
        class $DECL_SPEC OutsideNS {
        public:
            int someMethod();
            int field;
            int field2;
        };";
    $SOURCE2 .= "
        int OutsideNS::someMethod() { return 0; }";

    # Begin namespace
    $HEADER1 .= "namespace TestNS {\n";
    $HEADER2 .= "namespace TestNS {\n";
    $SOURCE1 .= "namespace TestNS {\n";
    $SOURCE2 .= "namespace TestNS {\n";

    # Changed template internals
    # $HEADER1 .= "
    #     template <typename T, int _P>
    #     class $DECL_SPEC ChangedTemplate {
    #     public:
    #         T value;
    #         T*const field;
    #         T array[_P];
    #         typedef int My;
    #         My var;
    #     };
    #     ChangedTemplate<int, 1>* changedTemplate();";
    # $SOURCE1 .= "
    #     ChangedTemplate<int, 1>* changedTemplate() { return new ChangedTemplate<int, 1>(); }";
    #
    # $HEADER2 .= "
    #     template <typename T, int _P>
    #     class $DECL_SPEC ChangedTemplate {
    #     public:
    #         double value;
    #         T* field;
    #         double array[_P];
    #         typedef int My;
    #         My var;
    #     };
    #     ChangedTemplate<int, 1>* changedTemplate();";
    # $SOURCE2 .= "
    #     ChangedTemplate<int, 1>* changedTemplate() { return new ChangedTemplate<int, 1>(); }";

    # Removed inline method
    $HEADER1 .= "
        class $DECL_SPEC RemovedInlineMethod {
        public:
            int someMethod();
            inline int removedMethod() { return 0; };
            int field;
        };";
    $SOURCE1 .= "
        int RemovedInlineMethod::someMethod() { return removedMethod(); }";

    $HEADER2 .= "
        class $DECL_SPEC RemovedInlineMethod {
        public:
            int someMethod();
            int field;
        };";
    $SOURCE2 .= "
        int RemovedInlineMethod::someMethod() { return 0; }";

    # Pure_Virtual_Replacement
    $HEADER1 .= "
        class $DECL_SPEC PureVirtualReplacement {
        public:
            virtual int methodOld(int param) = 0;
            int otherMethod();
        };

        class $DECL_SPEC PureVirtualReplacement_Derived: public PureVirtualReplacement {
        public:
            int methodOld(int param);
        };";
    $SOURCE1 .= "
        int PureVirtualReplacement::otherMethod() { return 0; }
        int PureVirtualReplacement_Derived::methodOld(int param) { return 0; }";

    $HEADER2 .= "
        class $DECL_SPEC PureVirtualReplacement {
        public:
            virtual int methodNew(int param) = 0;
            int otherMethod();
        };

        class $DECL_SPEC PureVirtualReplacement_Derived: public PureVirtualReplacement {
        public:
            int methodNew(int param);
        };";
    $SOURCE2 .= "
        int PureVirtualReplacement::otherMethod() { return 0; }
        int PureVirtualReplacement_Derived::methodNew(int param) { return 0; }";

    # Virtual_Replacement
    $HEADER1 .= "
        class $DECL_SPEC VirtualReplacement {
        public:
            virtual int methodOld(int param);
        };";
    $SOURCE1 .= "
        int VirtualReplacement::methodOld(int param) { return 0; }";

    $HEADER2 .= "
        class $DECL_SPEC VirtualReplacement {
        public:
            virtual int methodNew(int param);
        };";
    $SOURCE2 .= "
        int VirtualReplacement::methodNew(int param) { return 0; }";

    # Removed_Symbol (renamed, source-compatible)
    $HEADER1 .= "
        int $DECL_SPEC renamedFunc(int param);";
    $SOURCE1 .= "
        int renamedFunc(int param) { return 0; }";

    $HEADER2 .= "
        int $DECL_SPEC renamedFunc_NewName(int param);
        #define renamedFunc renamedFunc_NewName";
    $SOURCE2 .= "
        int renamedFunc_NewName(int param) { return 0; }";

    # Removed_Symbol
    $HEADER1 .= "
        int $DECL_SPEC functionBecameInline(int param);";
    $SOURCE1 .= "
        int functionBecameInline(int param) { return 0; }";

    $HEADER2 .= "
        inline int functionBecameInline(int param) { return 0; }";

    # Removed_Symbol (safe)
    $HEADER1 .= "
        inline int removedInlineFunction(int param) { return 0; }";

    # Became Non-Opaque
    $HEADER1 .= "
        struct OpaqueStruct;
        int paramBecameNonOpaque(OpaqueStruct* p);";
    $SOURCE1 .= "
        int paramBecameNonOpaque(OpaqueStruct* p) { return 0; }";

    $HEADER2 .= "
        struct OpaqueStruct
        {
            int i;
            short j;
            OpaqueStruct();
        };
        int paramBecameNonOpaque(OpaqueStruct* p);";
    $SOURCE2 .= "
        int paramBecameNonOpaque(OpaqueStruct* p) { return 0; }";

    # Field_Became_Const
    # Typedef
    $HEADER1 .= "
        typedef int*const CONST_INT_PTR;
        class $DECL_SPEC FieldBecameConstTypedef {
        public:
            int* f;
            int*const f2;
            int method(CONST_INT_PTR p);
        };";
    $SOURCE1 .= "
        int FieldBecameConstTypedef::method(CONST_INT_PTR p) { return 0; }";

    $HEADER2 .= "
        typedef int*const CONST_INT_PTR;
        class $DECL_SPEC FieldBecameConstTypedef {
        public:
            CONST_INT_PTR f;
            int*const f2;
            int method(CONST_INT_PTR p);
        };";
    $SOURCE2 .= "
        int FieldBecameConstTypedef::method(CONST_INT_PTR p) { return 0; }";

    # Field_Removed_Const
    $HEADER1 .= "
        class $DECL_SPEC FieldRemovedConst {
        public:
            int*const*const f;
            int method();
        };";
    $SOURCE1 .= "
        int FieldRemovedConst::method() { return 0; }";

    $HEADER2 .= "
        class $DECL_SPEC FieldRemovedConst {
        public:
            int**const f;
            int method();
        };";
    $SOURCE2 .= "
        int FieldRemovedConst::method() { return 0; }";

    # Field_Became_Const
    $HEADER1 .= "
        class $DECL_SPEC FieldBecameConst {
        public:
            int* f;
            int method();
        };";
    $SOURCE1 .= "
        int FieldBecameConst::method() { return 0; }";

    $HEADER2 .= "
        class $DECL_SPEC FieldBecameConst {
        public:
            int*const f;
            int method();
        };";
    $SOURCE2 .= "
        int FieldBecameConst::method() { return 0; }";

    # Field_Became_Private
    $HEADER1 .= "
        class $DECL_SPEC FieldBecamePrivate {
        public:
            int* f;
            int method();
        };";
    $SOURCE1 .= "
        int FieldBecamePrivate::method() { return 0; }";

    $HEADER2 .= "
        class $DECL_SPEC FieldBecamePrivate {
        private:
            int* f;
        public:
            int method();
        };";
    $SOURCE2 .= "
        int FieldBecamePrivate::method() { return 0; }";

    # Field_Became_Protected
    $HEADER1 .= "
        class $DECL_SPEC FieldBecameProtected {
        public:
            int* f;
            int method();
        };";
    $SOURCE1 .= "
        int FieldBecameProtected::method() { return 0; }";

    $HEADER2 .= "
        class $DECL_SPEC FieldBecameProtected {
        protected:
            int* f;
        public:
            int method();
        };";
    $SOURCE2 .= "
        int FieldBecameProtected::method() { return 0; }";

    # Global_Data_Became_Private
    $HEADER1 .= "
        class $DECL_SPEC GlobalDataBecamePrivate {
        public:
            static int data;

        };";
    $SOURCE1 .= "
        int GlobalDataBecamePrivate::data = 10;";

    $HEADER2 .= "
        class $DECL_SPEC GlobalDataBecamePrivate {
        private:
            static int data;

        };";
    $SOURCE2 .= "
        int GlobalDataBecamePrivate::data = 10;";

    # Method_Became_Private
    $HEADER1 .= "
        class $DECL_SPEC MethodBecamePrivate {
        public:
            int method();
        };";
    $SOURCE1 .= "
        int MethodBecamePrivate::method() { return 0; }";

    $HEADER2 .= "
        class $DECL_SPEC MethodBecamePrivate {
        private:
            int method();
        };";
    $SOURCE2 .= "
        int MethodBecamePrivate::method() { return 0; }";

    # Method_Became_Protected
    $HEADER1 .= "
        class $DECL_SPEC MethodBecameProtected {
        public:
            int method();
        };";
    $SOURCE1 .= "
        int MethodBecameProtected::method() { return 0; }";

    $HEADER2 .= "
        class $DECL_SPEC MethodBecameProtected {
        protected:
            int method();
        };";
    $SOURCE2 .= "
        int MethodBecameProtected::method() { return 0; }";

    # Method_Became_Public
    $HEADER1 .= "
        class $DECL_SPEC MethodBecamePublic {
        protected:
            int method();
        };";
    $SOURCE1 .= "
        int MethodBecamePublic::method() { return 0; }";

    $HEADER2 .= "
        class $DECL_SPEC MethodBecamePublic {
        public:
            int method();
        };";
    $SOURCE2 .= "
        int MethodBecamePublic::method() { return 0; }";

    # Removed_Const_Overload
    $HEADER1 .= "
        class $DECL_SPEC RemovedConstOverload {
        public:
            int removed();
            int removed() const;
        };";
    $SOURCE1 .= "
        int RemovedConstOverload::removed() { return 0; }
        int RemovedConstOverload::removed() const { return 0; }";

    $HEADER2 .= "
        class $DECL_SPEC RemovedConstOverload {
        public:
            int removed();
        };";
    $SOURCE2 .= "
        int RemovedConstOverload::removed() { return 0; }";

    # Inline method
    $HEADER1 .= "
        class $DECL_SPEC InlineMethod {
        public:
            inline int foo() { return 0; }
        };";

    $HEADER2 .= "
        class $DECL_SPEC InlineMethod {
        public:
            inline long foo() { return 0; }
        };";

    # Global_Data_Became_Non_Const
    $HEADER1 .= "
        $EXTERN $DECL_SPEC const int globalDataBecameNonConst = 10;";

    $HEADER2 .= "
        extern $DECL_SPEC int globalDataBecameNonConst;";
    $SOURCE2 .= "
        int globalDataBecameNonConst = 15;";

    # Global_Data_Became_Non_Const
    # Class Member
    $HEADER1 .= "
        class $DECL_SPEC GlobalDataBecameNonConst {
        public:
            static const int data;
        };";
    $SOURCE1 .= "
        const int GlobalDataBecameNonConst::data = 10;";

    $HEADER2 .= "
        class $DECL_SPEC GlobalDataBecameNonConst {
        public:
            static int data;
        };";
    $SOURCE2 .= "
        int GlobalDataBecameNonConst::data = 10;";

    # Global_Data_Became_Const
    $HEADER1 .= "
        extern $DECL_SPEC int globalDataBecameConst;";
    $SOURCE1 .= "
        int globalDataBecameConst = 10;";

    $HEADER2 .= "
        $EXTERN $DECL_SPEC const int globalDataBecameConst = 15;";

    # Global_Data_Became_Const
    # Class Member
    $HEADER1 .= "
        class $DECL_SPEC GlobalDataBecameConst {
        public:
            static int Data;
        };";
    $SOURCE1 .= "
        int GlobalDataBecameConst::Data = 10;";

    $HEADER2 .= "
        class $DECL_SPEC GlobalDataBecameConst {
        public:
            static const int Data = 15;
        };";

    # Global_Data_Value_Changed
    $HEADER1 .= "
        class $DECL_SPEC GlobalDataValue {
        public:
            static const int Integer = 10;
            static const char Char = \'o\';
        };";

    $HEADER2 .= "
        class $DECL_SPEC GlobalDataValue {
        public:
            static const int Integer = 15;
            static const char Char = \'N\';
        };";

    # Global_Data_Value_Changed
    # Integer
    $HEADER1 .= "
        $EXTERN $DECL_SPEC const int globalDataValue_Integer = 10;";

    $HEADER2 .= "
        $EXTERN $DECL_SPEC const int globalDataValue_Integer = 15;";

    # Global_Data_Value_Changed
    # Character
    $HEADER1 .= "
        $EXTERN $DECL_SPEC const char globalDataValue_Char = \'o\';";

    $HEADER2 .= "
        $EXTERN $DECL_SPEC const char globalDataValue_Char = \'N\';";

    # Parameter_Became_Restrict
    $HEADER1 .= "
        class $DECL_SPEC ParameterBecameRestrict {
        public:
            int method(int* param);
        };";
    $SOURCE1 .= "
        int ParameterBecameRestrict::method(int* param) { return 0; }";

    $HEADER2 .= "
        class $DECL_SPEC ParameterBecameRestrict {
        public:
            int method(int* __restrict param);
        };";
    $SOURCE2 .= "
        int ParameterBecameRestrict::method(int* __restrict param) { return 0; }";

    # Parameter_Became_Non_Restrict
    $HEADER1 .= "
        class $DECL_SPEC ParameterBecameNonRestrict {
        public:
            int method(int* __restrict param);
        };";
    $SOURCE1 .= "
        int ParameterBecameNonRestrict::method(int* __restrict param) { return 0; }";

    $HEADER2 .= "
        class $DECL_SPEC ParameterBecameNonRestrict {
        public:
            int method(int* param);
        };";
    $SOURCE2 .= "
        int ParameterBecameNonRestrict::method(int* param) { return 0; }";

    # Field_Became_Volatile
    $HEADER1 .= "
        class $DECL_SPEC FieldBecameVolatile {
        public:
            int method(int param);
            int f;
        };";
    $SOURCE1 .= "
        int FieldBecameVolatile::method(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC FieldBecameVolatile {
        public:
            int method(int param);
            volatile int f;
        };";
    $SOURCE2 .= "
        int FieldBecameVolatile::method(int param) { return param; }";

    # Field_Became_Non_Volatile
    $HEADER1 .= "
        class $DECL_SPEC FieldBecameNonVolatile {
        public:
            int method(int param);
            volatile int f;
        };";
    $SOURCE1 .= "
        int FieldBecameNonVolatile::method(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC FieldBecameNonVolatile {
        public:
            int method(int param);
            int f;
        };";
    $SOURCE2 .= "
        int FieldBecameNonVolatile::method(int param) { return param; }";

    # Field_Became_Mutable
    $HEADER1 .= "
        class $DECL_SPEC FieldBecameMutable {
        public:
            int method(int param);
            int f;
        };";
    $SOURCE1 .= "
        int FieldBecameMutable::method(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC FieldBecameMutable {
        public:
            int method(int param);
            mutable int f;
        };";
    $SOURCE2 .= "
        int FieldBecameMutable::method(int param) { return param; }";

    # Field_Became_Non_Mutable
    $HEADER1 .= "
        class $DECL_SPEC FieldBecameNonMutable {
        public:
            int method(int param);
            mutable int f;
        };";
    $SOURCE1 .= "
        int FieldBecameNonMutable::method(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC FieldBecameNonMutable {
        public:
            int method(int param);
            int f;
        };";
    $SOURCE2 .= "
        int FieldBecameNonMutable::method(int param) { return param; }";

    # Method_Became_Const
    # Method_Became_Volatile
    $HEADER1 .= "
        class $DECL_SPEC MethodBecameConstVolatile {
        public:
            int method(int param);
        };";
    $SOURCE1 .= "
        int MethodBecameConstVolatile::method(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC MethodBecameConstVolatile {
        public:
            int method(int param) volatile const;
        };";
    $SOURCE2 .= "
        int MethodBecameConstVolatile::method(int param) volatile const { return param; }";

    # Method_Became_Const
    $HEADER1 .= "
        class $DECL_SPEC MethodBecameConst {
        public:
            int method(int param);
        };";
    $SOURCE1 .= "
        int MethodBecameConst::method(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC MethodBecameConst {
        public:
            int method(int param) const;
        };";
    $SOURCE2 .= "
        int MethodBecameConst::method(int param) const { return param; }";

    # Method_Became_Non_Const
    $HEADER1 .= "
        class $DECL_SPEC MethodBecameNonConst {
        public:
            int method(int param) const;
        };";
    $SOURCE1 .= "
        int MethodBecameNonConst::method(int param) const { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC MethodBecameNonConst {
        public:
            int method(int param);
        };";
    $SOURCE2 .= "
        int MethodBecameNonConst::method(int param) { return param; }";

    # Method_Became_Volatile
    $HEADER1 .= "
        class $DECL_SPEC MethodBecameVolatile {
        public:
            int method(int param);
        };";
    $SOURCE1 .= "
        int MethodBecameVolatile::method(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC MethodBecameVolatile {
        public:
            int method(int param) volatile;
        };";
    $SOURCE2 .= "
        int MethodBecameVolatile::method(int param) volatile { return param; }";

    # Virtual_Method_Position
    # Multiple bases
    $HEADER1 .= "
        class $DECL_SPEC PrimaryBase
        {
        public:
            virtual ~PrimaryBase();
            virtual void foo();
        };
        class $DECL_SPEC SecondaryBase
        {
        public:
            virtual ~SecondaryBase();
            virtual void bar();
        };
        class UnsafeVirtualOverride: public PrimaryBase, public SecondaryBase
        {
        public:
            UnsafeVirtualOverride();
            ~UnsafeVirtualOverride();
            void foo();
        };";
    $SOURCE1 .= "
        PrimaryBase::~PrimaryBase() { }
        void PrimaryBase::foo() { }

        SecondaryBase::~SecondaryBase() { }
        void SecondaryBase::bar() { }

        UnsafeVirtualOverride::UnsafeVirtualOverride() { }
        UnsafeVirtualOverride::~UnsafeVirtualOverride() { }
        void UnsafeVirtualOverride::foo() { }";

    $HEADER2 .= "
        class $DECL_SPEC PrimaryBase
        {
        public:
            virtual ~PrimaryBase();
            virtual void foo();
        };
        class $DECL_SPEC SecondaryBase
        {
        public:
            virtual ~SecondaryBase();
            virtual void bar();
        };
        class UnsafeVirtualOverride: public PrimaryBase, public SecondaryBase
        {
        public:
            UnsafeVirtualOverride();
            ~UnsafeVirtualOverride();
            void foo();
            void bar();
        };";
    $SOURCE2 .= "
        PrimaryBase::~PrimaryBase() { }
        void PrimaryBase::foo() { }

        SecondaryBase::~SecondaryBase() { }
        void SecondaryBase::bar() { }

        UnsafeVirtualOverride::UnsafeVirtualOverride() { }
        UnsafeVirtualOverride::~UnsafeVirtualOverride() { }
        void UnsafeVirtualOverride::foo() { }
        void UnsafeVirtualOverride::bar() { }";

    # Removed_Interface (inline virtual d-tor)
    $HEADER1 .= "
        template <typename T>
        class $DECL_SPEC BaseTemplate {
        public:
            BaseTemplate() { }
            virtual int method(int param) { return param; };
            virtual ~BaseTemplate() { };
        };
        class $DECL_SPEC RemovedVirtualDestructor: public BaseTemplate<int> {
        public:
            RemovedVirtualDestructor() { };
            virtual int method2(int param);
        };";
    $SOURCE1 .= "
        int RemovedVirtualDestructor::method2(int param) { return param; }";

    $HEADER2 .= "
        template <typename T>
        class $DECL_SPEC BaseTemplate {
        public:
            BaseTemplate() { }
            virtual int method(int param) { return param; };
            //virtual ~BaseTemplate() { };
        };
        class $DECL_SPEC RemovedVirtualDestructor: public BaseTemplate<int> {
        public:
            RemovedVirtualDestructor() { };
            virtual int method2(int param);
        };";
    $SOURCE2 .= "
        int RemovedVirtualDestructor::method2(int param) { return param; }";

    # Added_Virtual_Method_At_End
    $HEADER1 .= "
        class $DECL_SPEC DefaultConstructor {
        public:
            DefaultConstructor() { }
            virtual int method(int param);
        };";
    $SOURCE1 .= "
        int DefaultConstructor::method(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC DefaultConstructor {
        public:
            DefaultConstructor() { }
            virtual int method(int param);
            virtual int addedMethod(int param);
        };";
    $SOURCE2 .= "
        int DefaultConstructor::method(int param) { return addedMethod(param); }
        int DefaultConstructor::addedMethod(int param) { return param; }";

    # Added_Enum_Member
    $HEADER1 .= "
        enum AddedEnumMember {
            OldMember
        };
        $DECL_SPEC int addedEnumMember(enum AddedEnumMember param);";
    $SOURCE1 .= "
        int addedEnumMember(enum AddedEnumMember param) { return 0; }";

    $HEADER2 .= "
        enum AddedEnumMember {
            OldMember,
            NewMember
        };
        $DECL_SPEC int addedEnumMember(enum AddedEnumMember param);";
    $SOURCE2 .= "
        int addedEnumMember(enum AddedEnumMember param) { return 0; }";

    # Parameter_Type_Format (Safe)
    $HEADER1 .= "
        struct DType
        {
            int i;
            double j;
        };
        $DECL_SPEC int parameterTypeFormat_Safe(struct DType param);";
    $SOURCE1 .= "
        int parameterTypeFormat_Safe(struct DType param) { return 0; }";

    $HEADER2 .= "
        class DType
        {
            int i;
            double j;
        };
        $DECL_SPEC int parameterTypeFormat_Safe(class DType param);";
    $SOURCE2 .= "
        int parameterTypeFormat_Safe(class DType param) { return 0; }";

    # Type_Became_Opaque (Struct)
    $HEADER1 .= "
        struct StructBecameOpaque
        {
            int i, j;
        };
        $DECL_SPEC int structBecameOpaque(struct StructBecameOpaque* param);";
    $SOURCE1 .= "
        int structBecameOpaque(struct StructBecameOpaque* param) { return 0; }";

    $HEADER2 .= "
        struct StructBecameOpaque;
        $DECL_SPEC int structBecameOpaque(struct StructBecameOpaque* param);";
    $SOURCE2 .= "
        int structBecameOpaque(struct StructBecameOpaque* param) { return 0; }";

    # Type_Became_Opaque (Union)
    $HEADER1 .= "
        union UnionBecameOpaque
        {
            int i, j;
        };
        $DECL_SPEC int unionBecameOpaque(union UnionBecameOpaque* param);";
    $SOURCE1 .= "
        int unionBecameOpaque(union UnionBecameOpaque* param) { return 0; }";

    $HEADER2 .= "
        union UnionBecameOpaque;
        $DECL_SPEC int unionBecameOpaque(union UnionBecameOpaque* param);";
    $SOURCE2 .= "
        int unionBecameOpaque(union UnionBecameOpaque* param) { return 0; }";

    # Field_Type_Format
    $HEADER1 .= "
        struct DType1
        {
            int i;
            double j[7];
        };
        struct FieldTypeFormat
        {
            int i;
            struct DType1 j;
        };
        $DECL_SPEC int fieldTypeFormat(struct FieldTypeFormat param);";
    $SOURCE1 .= "
        int fieldTypeFormat(struct FieldTypeFormat param) { return 0; }";

    $HEADER2 .= "
        struct DType2
        {
            double i[7];
            int j;
        };
        struct FieldTypeFormat
        {
            int i;
            struct DType2 j;
        };
        $DECL_SPEC int fieldTypeFormat(struct FieldTypeFormat param);";
    $SOURCE2 .= "
        int fieldTypeFormat(struct FieldTypeFormat param) { return 0; }";

    # Field_Type_Format (func ptr)
    $HEADER1 .= "
        typedef void (*FuncPtr_Old) (int a);
        struct FieldTypeFormat_FuncPtr
        {
            int i;
            FuncPtr_Old j;
        };
        $DECL_SPEC int fieldTypeFormat_FuncPtr(struct FieldTypeFormat_FuncPtr param);";
    $SOURCE1 .= "
        int fieldTypeFormat_FuncPtr(struct FieldTypeFormat_FuncPtr param) { return 0; }";

    $HEADER2 .= "
        typedef void (*FuncPtr_New) (int a, int b);
        struct FieldTypeFormat_FuncPtr
        {
            int i;
            FuncPtr_New j;
        };
        $DECL_SPEC int fieldTypeFormat_FuncPtr(struct FieldTypeFormat_FuncPtr param);";
    $SOURCE2 .= "
        int fieldTypeFormat_FuncPtr(struct FieldTypeFormat_FuncPtr param) { return 0; }";

    # Removed_Virtual_Method (inline)
    $HEADER1 .= "
        class $DECL_SPEC RemovedInlineVirtualFunction {
        public:
            RemovedInlineVirtualFunction();
            virtual int removedMethod(int param) { return 0; }
            virtual int method(int param);
        };";
    $SOURCE1 .= "
        int RemovedInlineVirtualFunction::method(int param) { return param; }
        RemovedInlineVirtualFunction::RemovedInlineVirtualFunction() { }";

    $HEADER2 .= "
        class $DECL_SPEC RemovedInlineVirtualFunction {
        public:
            RemovedInlineVirtualFunction();
            virtual int method(int param);
        };";
    $SOURCE2 .= "
        int RemovedInlineVirtualFunction::method(int param) { return param; }
        RemovedInlineVirtualFunction::RemovedInlineVirtualFunction() { }";

    # MethodPtr
    $HEADER1 .= "
        class TestMethodPtr {
            public:
                typedef void (TestMethodPtr::*Method)(int*);
                Method _method;
                TestMethodPtr();
                void method();
        };";
    $SOURCE1 .= "
        TestMethodPtr::TestMethodPtr() { }
        void TestMethodPtr::method() { }";

    $HEADER2 .= "
        class TestMethodPtr {
            public:
                typedef void (TestMethodPtr::*Method)(int*, void*);
                Method _method;
                TestMethodPtr();
                void method();
        };";
    $SOURCE2 .= "
        TestMethodPtr::TestMethodPtr() { }
        void TestMethodPtr::method() { }";

    # FieldPtr
    $HEADER1 .= "
        class TestFieldPtr {
            public:
                typedef void* (TestFieldPtr::*Field);
                Field _field;
                TestFieldPtr();
                void method(void*);
        };";
    $SOURCE1 .= "
        TestFieldPtr::TestFieldPtr(){ }
        void TestFieldPtr::method(void*) { }";

    $HEADER2 .= "
        class TestFieldPtr {
            public:
                typedef int (TestFieldPtr::*Field);
                Field _field;
                TestFieldPtr();
                void method(void*);
        };";
    $SOURCE2 .= "
        TestFieldPtr::TestFieldPtr(){ }
        void TestFieldPtr::method(void*) { }";

    # Removed_Symbol (Template Specializations)
    $HEADER1 .= "
        template <unsigned int _TP, typename AAA>
        class Template {
            public:
                char const *field;
        };
        template <unsigned int _TP, typename AAA>
        class TestRemovedTemplate {
            public:
                char const *field;
                void method(int);
        };
        template <>
        class TestRemovedTemplate<7, char> {
            public:
                char const *field;
                void method(int);
        };";
    $SOURCE1 .= "
        void TestRemovedTemplate<7, char>::method(int){ }";

    # Removed_Symbol (Template Specializations)
    $HEADER1 .= "
        template <typename TName>
        int removedTemplateSpec(TName);

        template <> int removedTemplateSpec<char>(char);";
    $SOURCE1 .= "
        template <> int removedTemplateSpec<char>(char){return 0;}";

    # Removed_Field (Ref)
    $HEADER1 .= "
        struct TestRefChange {
            int a, b, c;
        };
        $DECL_SPEC int paramRefChange(const TestRefChange & p1, int p2);";
    $SOURCE1 .= "
        int paramRefChange(const TestRefChange & p1, int p2) { return p2; }";

    $HEADER2 .= "
        struct TestRefChange {
            int a, b;
        };
        $DECL_SPEC int paramRefChange(const TestRefChange & p1, int p2);";
    $SOURCE2 .= "
        int paramRefChange(const TestRefChange & p1, int p2) { return p2; }";

    # Removed_Parameter
    $HEADER1 .= "
        $DECL_SPEC int removedParameter(int param, int removed_param);";
    $SOURCE1 .= "
        int removedParameter(int param, int removed_param) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC int removedParameter(int param);";
    $SOURCE2 .= "
        int removedParameter(int param) { return 0; }";

    # Added_Parameter
    $HEADER1 .= "
        $DECL_SPEC int addedParameter(int param);";
    $SOURCE1 .= "
        int addedParameter(int param) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC int addedParameter(int param, int added_param);";
    $SOURCE2 .= "
        int addedParameter(int param, int added_param) { return 0; }";

    # Added
    $HEADER2 .= "
        typedef int (*FUNCPTR_TYPE)(int a, int b);
        $DECL_SPEC int addedFunc(FUNCPTR_TYPE*const** f);";
    $SOURCE2 .= "
        int addedFunc(FUNCPTR_TYPE*const** f) { return 0; }";

    # Added (3)
    $HEADER2 .= "
        struct DStruct
        {
            int i, j, k;
        };
        int addedFunc3(struct DStruct* p);";
    $SOURCE2 .= "
        int addedFunc3(struct DStruct* p) { return 0; }";

    # Added_Virtual_Method
    $HEADER1 .= "
        class $DECL_SPEC AddedVirtualMethod {
        public:
            virtual int method(int param);
        };";
    $SOURCE1 .= "
        int AddedVirtualMethod::method(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC AddedVirtualMethod {
        public:
            virtual int addedMethod(int param);
            virtual int method(int param);
        };";
    $SOURCE2 .= "
        int AddedVirtualMethod::addedMethod(int param) {
            return param;
        }
        int AddedVirtualMethod::method(int param) { return param; }";

    # Added_Virtual_Method (added "virtual" attribute)
    $HEADER1 .= "
        class $DECL_SPEC BecameVirtualMethod {
        public:
            int becameVirtual(int param);
            virtual int method(int param);
        };";
    $SOURCE1 .= "
        int BecameVirtualMethod::becameVirtual(int param) { return param; }
        int BecameVirtualMethod::method(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC BecameVirtualMethod {
        public:
            virtual int becameVirtual(int param);
            virtual int method(int param);
        };";
    $SOURCE2 .= "
        int BecameVirtualMethod::becameVirtual(int param) { return param; }
        int BecameVirtualMethod::method(int param) { return param; }";

    # Added_Pure_Virtual_Method
    $HEADER1 .= "
        class $DECL_SPEC AddedPureVirtualMethod {
        public:
            virtual int method(int param);
            int otherMethod(int param);
        };";
    $SOURCE1 .= "
        int AddedPureVirtualMethod::method(int param) { return param; }
        int AddedPureVirtualMethod::otherMethod(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC AddedPureVirtualMethod {
        public:
            virtual int addedMethod(int param)=0;
            virtual int method(int param);
            int otherMethod(int param);
        };";
    $SOURCE2 .= "
        int AddedPureVirtualMethod::method(int param) { return param; }
        int AddedPureVirtualMethod::otherMethod(int param) { return param; }";

    # Added_Virtual_Method_At_End (Safe)
    $HEADER1 .= "
        class $DECL_SPEC AddedVirtualMethodAtEnd {
        public:
            AddedVirtualMethodAtEnd();
            int method1(int param);
            virtual int method2(int param);
        };";
    $SOURCE1 .= "
        AddedVirtualMethodAtEnd::AddedVirtualMethodAtEnd() { }
        int AddedVirtualMethodAtEnd::method1(int param) { return param; }
        int AddedVirtualMethodAtEnd::method2(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC AddedVirtualMethodAtEnd {
        public:
            AddedVirtualMethodAtEnd();
            int method1(int param);
            virtual int method2(int param);
            virtual int addedMethod(int param);
        };";
    $SOURCE2 .= "
        AddedVirtualMethodAtEnd::AddedVirtualMethodAtEnd() { }
        int AddedVirtualMethodAtEnd::method1(int param) { return param; }
        int AddedVirtualMethodAtEnd::method2(int param) { return param; }
        int AddedVirtualMethodAtEnd::addedMethod(int param) { return param; }";

    # Added_Virtual_Method_At_End (With Default Constructor)
    $HEADER1 .= "
        class $DECL_SPEC AddedVirtualMethodAtEnd_DefaultConstructor {
        public:
            int method1(int param);
            virtual int method2(int param);
        };";
    $SOURCE1 .= "
        int AddedVirtualMethodAtEnd_DefaultConstructor::method1(int param) { return param; }
        int AddedVirtualMethodAtEnd_DefaultConstructor::method2(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC AddedVirtualMethodAtEnd_DefaultConstructor {
        public:
            int method1(int param);
            virtual int method2(int param);
            virtual int addedMethod(int param);
        };";
    $SOURCE2 .= "
        int AddedVirtualMethodAtEnd_DefaultConstructor::method1(int param) { return param; }
        int AddedVirtualMethodAtEnd_DefaultConstructor::method2(int param) { return param; }
        int AddedVirtualMethodAtEnd_DefaultConstructor::addedMethod(int param) { return param; }";

    # Added_First_Virtual_Method
    $HEADER1 .= "
        class $DECL_SPEC AddedFirstVirtualMethod {
        public:
            int method(int param);
        };";
    $SOURCE1 .= "
        int AddedFirstVirtualMethod::method(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC AddedFirstVirtualMethod {
        public:
            int method(int param);
            virtual int addedMethod(int param);
        };";
    $SOURCE2 .= "
        int AddedFirstVirtualMethod::method(int param) { return param; }
        int AddedFirstVirtualMethod::addedMethod(int param) { return param; }";

    # Removed_Virtual_Method
    $HEADER1 .= "
        class $DECL_SPEC RemovedVirtualFunction {
        public:
            int a, b, c;
            virtual int removedMethod(int param);
            virtual int vMethod(int param);
    };";
    $SOURCE1 .= "
        int RemovedVirtualFunction::removedMethod(int param) { return param; }
        int RemovedVirtualFunction::vMethod(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC RemovedVirtualFunction {
        public:
            int a, b, c;
            int removedMethod(int param);
            virtual int vMethod(int param);
    };";
    $SOURCE2 .= "
        int RemovedVirtualFunction::removedMethod(int param) { return param; }
        int RemovedVirtualFunction::vMethod(int param) { return param; }";

    # Removed_Virtual_Method (Pure, From the End)
    $HEADER1 .= "
        class $DECL_SPEC RemovedPureVirtualMethodFromEnd {
        public:
            virtual int method(int param);
            virtual int removedMethod(int param)=0;
        };";
    $SOURCE1 .= "
        int RemovedPureVirtualMethodFromEnd::method(int param) { return param; }
        int RemovedPureVirtualMethodFromEnd::removedMethod(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC RemovedPureVirtualMethodFromEnd
        {
        public:
            virtual int method(int param);
            int removedMethod(int param);
        };";
    $SOURCE2 .= "
        int RemovedPureVirtualMethodFromEnd::method(int param) { return param; }
        int RemovedPureVirtualMethodFromEnd::removedMethod(int param) { return param; }";

    # Removed_Symbol (Pure with Implementation)
    $HEADER1 .= "
        class $DECL_SPEC RemovedPureSymbol {
        public:
            virtual int method(int param);
            virtual int removedMethod(int param)=0;
        };";
    $SOURCE1 .= "
        int RemovedPureSymbol::method(int param) { return param; }
        int RemovedPureSymbol::removedMethod(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC RemovedPureSymbol
        {
        public:
            virtual int method(int param);
        };";
    $SOURCE2 .= "
        int RemovedPureSymbol::method(int param) { return param; }";

    # Removed_Virtual_Method (From the End)
    $HEADER1 .= "
        class $DECL_SPEC RemovedVirtualMethodFromEnd {
        public:
            virtual int method(int param);
            virtual int removedMethod(int param);
        };";
    $SOURCE1 .= "
        int RemovedVirtualMethodFromEnd::method(int param) { return param; }
        int RemovedVirtualMethodFromEnd::removedMethod(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC RemovedVirtualMethodFromEnd
        {
        public:
            virtual int method(int param);
            int removedMethod(int param);
        };";
    $SOURCE2 .= "
        int RemovedVirtualMethodFromEnd::method(int param) { return param; }
        int RemovedVirtualMethodFromEnd::removedMethod(int param) { return param; }";

    # Removed_Last_Virtual_Method
    $HEADER1 .= "
        class $DECL_SPEC RemovedLastVirtualMethod
        {
        public:
            int method(int param);
            virtual int removedMethod(int param);
        };";
    $SOURCE1 .= "
        int RemovedLastVirtualMethod::method(int param) { return param; }";
    $SOURCE1 .= "
        int RemovedLastVirtualMethod::removedMethod(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC RemovedLastVirtualMethod
        {
        public:
            int method(int param);
            int removedMethod(int param);
        };";
    $SOURCE2 .= "
        int RemovedLastVirtualMethod::method(int param) { return param; }";
    $SOURCE2 .= "
        int RemovedLastVirtualMethod::removedMethod(int param) { return param; }";

    # Virtual_Table_Size
    $HEADER1 .= "
        class $DECL_SPEC VirtualTableSize
        {
        public:
            virtual int method1(int param);
            virtual int method2(int param);
        };
        class $DECL_SPEC VirtualTableSize_SubClass: public VirtualTableSize
        {
        public:
            virtual int method3(int param);
            virtual int method4(int param);
        };";
    $SOURCE1 .= "
        int VirtualTableSize::method1(int param) { return param; }
        int VirtualTableSize::method2(int param) { return param; }
        int VirtualTableSize_SubClass::method3(int param) { return param; }
        int VirtualTableSize_SubClass::method4(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC VirtualTableSize
        {
        public:
            virtual int method1(int param);
            virtual int method2(int param);
            virtual int addedMethod(int param);
        };
        class $DECL_SPEC VirtualTableSize_SubClass: public VirtualTableSize
        {
        public:
            virtual int method3(int param);
            virtual int method4(int param);
        };";
    $SOURCE2 .= "
        int VirtualTableSize::method1(int param) { return param; }
        int VirtualTableSize::method2(int param) { return param; }
        int VirtualTableSize::addedMethod(int param) { return param; }
        int VirtualTableSize_SubClass::method3(int param) { return param; }
        int VirtualTableSize_SubClass::method4(int param) { return param; }";

    # Virtual_Method_Position
    $HEADER1 .= "
        class $DECL_SPEC VirtualMethodPosition
        {
        public:
            virtual int method1(int param);
            virtual int method2(int param);
        };";
    $SOURCE1 .= "
        int VirtualMethodPosition::method1(int param) { return param; }";
    $SOURCE1 .= "
        int VirtualMethodPosition::method2(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC VirtualMethodPosition
        {
        public:
            virtual int method2(int param);
            virtual int method1(int param);
        };";
    $SOURCE2 .= "
        int VirtualMethodPosition::method1(int param) { return param; }";
    $SOURCE2 .= "
        int VirtualMethodPosition::method2(int param) { return param; }";

    # Pure_Virtual_Method_Position
    $HEADER1 .= "
        class $DECL_SPEC PureVirtualFunctionPosition {
        public:
            virtual int method1(int param)=0;
            virtual int method2(int param)=0;
            int method3(int param);
        };";
    $SOURCE1 .= "
        int PureVirtualFunctionPosition::method3(int param) { return method1(7)+method2(7); }";

    $HEADER2 .= "
        class $DECL_SPEC PureVirtualFunctionPosition {
        public:
            virtual int method2(int param)=0;
            virtual int method1(int param)=0;
            int method3(int param);
        };";
    $SOURCE2 .= "
        int PureVirtualFunctionPosition::method3(int param) { return method1(7)+method2(7); }";

    # Virtual_Method_Position
    $HEADER1 .= "
        class $DECL_SPEC VirtualFunctionPosition {
        public:
            virtual int method1(int param);
            virtual int method2(int param);
        };";
    $SOURCE1 .= "
        int VirtualFunctionPosition::method1(int param) { return 1; }
        int VirtualFunctionPosition::method2(int param) { return 2; }";

    $HEADER2 .= "
        class $DECL_SPEC VirtualFunctionPosition {
        public:
            virtual int method2(int param);
            virtual int method1(int param);
        };";
    $SOURCE2 .= "
        int VirtualFunctionPosition::method1(int param) { return 1; }
        int VirtualFunctionPosition::method2(int param) { return 2; }";

    # Virtual_Method_Position (safe)
    $HEADER1 .= "
        class $DECL_SPEC VirtualFunctionPositionSafe_Base {
        public:
            virtual int method1(int param);
            virtual int method2(int param);
        };
        class $DECL_SPEC VirtualFunctionPositionSafe: public VirtualFunctionPositionSafe_Base {
        public:
            virtual int method1(int param);
            virtual int method2(int param);
        };";
    $SOURCE1 .= "
        int VirtualFunctionPositionSafe_Base::method1(int param) { return param; }
        int VirtualFunctionPositionSafe_Base::method2(int param) { return param; }
        int VirtualFunctionPositionSafe::method1(int param) { return param; }
        int VirtualFunctionPositionSafe::method2(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC VirtualFunctionPositionSafe_Base {
        public:
            virtual int method1(int param);
            virtual int method2(int param);
        };
        class $DECL_SPEC VirtualFunctionPositionSafe: public VirtualFunctionPositionSafe_Base {
        public:
            virtual int method2(int param);
            virtual int method1(int param);
        };";
    $SOURCE2 .= "
        int VirtualFunctionPositionSafe_Base::method1(int param) { return param; }
        int VirtualFunctionPositionSafe_Base::method2(int param) { return param; }
        int VirtualFunctionPositionSafe::method1(int param) { return param; }
        int VirtualFunctionPositionSafe::method2(int param) { return param; }";

    # Overridden_Virtual_Method
    $HEADER1 .= "
        class $DECL_SPEC OverriddenVirtualMethod_Base {
        public:
            virtual int method1(int param);
            virtual int method2(int param);
        };
        class $DECL_SPEC OverriddenVirtualMethod: public OverriddenVirtualMethod_Base {
        public:
            OverriddenVirtualMethod();
            virtual int method3(int param);
        };";
    $SOURCE1 .= "
        int OverriddenVirtualMethod_Base::method1(int param) { return param; }
        int OverriddenVirtualMethod_Base::method2(int param) { return param; }
        OverriddenVirtualMethod::OverriddenVirtualMethod() {}
        int OverriddenVirtualMethod::method3(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC OverriddenVirtualMethod_Base {
        public:
            virtual int method1(int param);
            virtual int method2(int param);
        };
        class $DECL_SPEC OverriddenVirtualMethod:public OverriddenVirtualMethod_Base {
            OverriddenVirtualMethod();
            virtual int method2(int param);
            virtual int method3(int param);
        };";
    $SOURCE2 .= "
        int OverriddenVirtualMethod_Base::method1(int param) { return param; }
        int OverriddenVirtualMethod_Base::method2(int param) { return param; }
        OverriddenVirtualMethod::OverriddenVirtualMethod() {}
        int OverriddenVirtualMethod::method2(int param) { return param; }
        int OverriddenVirtualMethod::method3(int param) { return param; }";

    # Overridden_Virtual_Method_B (+ removed)
    $HEADER1 .= "

    class $DECL_SPEC OverriddenVirtualMethodB: public OverriddenVirtualMethod_Base {
        public:
            OverriddenVirtualMethodB();
            virtual int method2(int param);
            virtual int method3(int param);
    };";
    $SOURCE1 .= "
        OverriddenVirtualMethodB::OverriddenVirtualMethodB() {}
        int OverriddenVirtualMethodB::method2(int param) { return param; }
        int OverriddenVirtualMethodB::method3(int param) { return param; }";

    $HEADER2 .= "

    class $DECL_SPEC OverriddenVirtualMethodB:public OverriddenVirtualMethod_Base {
        public:
            OverriddenVirtualMethodB();
            virtual int method3(int param);
    };";
    $SOURCE2 .= "
        OverriddenVirtualMethodB::OverriddenVirtualMethodB() {}
        int OverriddenVirtualMethodB::method3(int param) { return param; }";

    # Size
    $HEADER1 .= "
        struct $DECL_SPEC TypeSize
        {
        public:
            TypeSize method(TypeSize param);
            int i[5];
            long j;
            double k;
            TypeSize* p;
        };";
    $SOURCE1 .= "
        TypeSize TypeSize::method(TypeSize param) { return param; }";

    $HEADER2 .= "
        struct $DECL_SPEC TypeSize
        {
        public:
            TypeSize method(TypeSize param);
            int i[15];
            long j;
            double k;
            TypeSize* p;
            int added_member;
        };";
    $SOURCE2 .= "
        TypeSize TypeSize::method(TypeSize param) { return param; }";

    # Size_Of_Allocable_Class_Increased
    $HEADER1 .= "
        class $DECL_SPEC AllocableClassSize
        {
        public:
            AllocableClassSize();
            int method();
            double p[5];
        };";
    $SOURCE1 .= "
        AllocableClassSize::AllocableClassSize() { }";
    $SOURCE1 .= "
        int AllocableClassSize::method() { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC AllocableClassSize
        {
        public:
            AllocableClassSize();
            int method();
            double p[15];
        };";
    $SOURCE2 .= "
        AllocableClassSize::AllocableClassSize() { }";
    $SOURCE2 .= "
        int AllocableClassSize::method() { return 0; }";

    # Size_Of_Allocable_Class_Decreased (decreased size, has derived class, has public members)
    $HEADER1 .= "
        class $DECL_SPEC DecreasedClassSize
        {
        public:
            DecreasedClassSize();
            int method();
            double p[15];
        };";
    $SOURCE1 .= "
        DecreasedClassSize::DecreasedClassSize() { }";
    $SOURCE1 .= "
        int DecreasedClassSize::method() { return 0; }";
    $HEADER1 .= "
        class $DECL_SPEC DecreasedClassSize_SubClass: public DecreasedClassSize
        {
        public:
            DecreasedClassSize_SubClass();
            int method();
            int f;
        };";
    $SOURCE1 .= "
        DecreasedClassSize_SubClass::DecreasedClassSize_SubClass() { f=7; }";
    $SOURCE1 .= "
        int DecreasedClassSize_SubClass::method() { return f; }";

    $HEADER2 .= "
        struct $DECL_SPEC DecreasedClassSize
        {
        public:
            DecreasedClassSize();
            int method();
            double p[5];
        };";
    $SOURCE2 .= "
        DecreasedClassSize::DecreasedClassSize() { }";
    $SOURCE2 .= "
        int DecreasedClassSize::method() { return 0; }";
    $HEADER2 .= "
        class $DECL_SPEC DecreasedClassSize_SubClass: public DecreasedClassSize
        {
        public:
            DecreasedClassSize_SubClass();
            int method();
            int f;
        };";
    $SOURCE2 .= "
        DecreasedClassSize_SubClass::DecreasedClassSize_SubClass() { f=7; }";
    $SOURCE2 .= "
        int DecreasedClassSize_SubClass::method() { return f; }";

    # Size_Of_Copying_Class
    $HEADER1 .= "
        class $DECL_SPEC CopyingClassSize
        {
        public:
            int method();
            int p[5];
        };";
    $SOURCE1 .= "
        int CopyingClassSize::method() { return p[4]; }";

    $HEADER2 .= "
        struct $DECL_SPEC CopyingClassSize
        {
        public:
            int method();
            int p[15];
        };";
    $SOURCE2 .= "
        int CopyingClassSize::method() { return p[10]; }";

    # Base_Class_Became_Virtually_Inherited
    $HEADER1 .= "
        class $DECL_SPEC BecameVirtualBase
        {
        public:
            BecameVirtualBase();
            int method();
            double p[5];
        };";
    $SOURCE1 .= "
        BecameVirtualBase::BecameVirtualBase() { }";
    $SOURCE1 .= "
        int BecameVirtualBase::method() { return 0; }";
    $HEADER1 .= "
        class $DECL_SPEC AddedVirtualBase1:public BecameVirtualBase
        {
        public:
            AddedVirtualBase1();
            int method();
        };";
    $SOURCE1 .= "
        AddedVirtualBase1::AddedVirtualBase1() { }";
    $SOURCE1 .= "
        int AddedVirtualBase1::method() { return 0; }";
    $HEADER1 .= "
        class $DECL_SPEC AddedVirtualBase2: public BecameVirtualBase
        {
        public:
            AddedVirtualBase2();
            int method();
        };";
    $SOURCE1 .= "
        AddedVirtualBase2::AddedVirtualBase2() { }";
    $SOURCE1 .= "
        int AddedVirtualBase2::method() { return 0; }";
    $HEADER1 .= "
        class $DECL_SPEC BaseClassBecameVirtuallyInherited:public AddedVirtualBase1, public AddedVirtualBase2
        {
        public:
            BaseClassBecameVirtuallyInherited();
        };";
    $SOURCE1 .= "
        BaseClassBecameVirtuallyInherited::BaseClassBecameVirtuallyInherited() { }";

    $HEADER2 .= "
        class $DECL_SPEC BecameVirtualBase
        {
        public:
            BecameVirtualBase();
            int method();
            double p[5];
        };";
    $SOURCE2 .= "
        BecameVirtualBase::BecameVirtualBase() { }";
    $SOURCE2 .= "
        int BecameVirtualBase::method() { return 0; }";
    $HEADER2 .= "
        class $DECL_SPEC AddedVirtualBase1:public virtual BecameVirtualBase
        {
        public:
            AddedVirtualBase1();
            int method();
        };";
    $SOURCE2 .= "
        AddedVirtualBase1::AddedVirtualBase1() { }";
    $SOURCE2 .= "
        int AddedVirtualBase1::method() { return 0; }";
    $HEADER2 .= "
        class $DECL_SPEC AddedVirtualBase2: public virtual BecameVirtualBase
        {
        public:
            AddedVirtualBase2();
            int method();
        };";
    $SOURCE2 .= "
        AddedVirtualBase2::AddedVirtualBase2() { }";
    $SOURCE2 .= "
        int AddedVirtualBase2::method() { return 0; }";
    $HEADER2 .= "
        class $DECL_SPEC BaseClassBecameVirtuallyInherited:public AddedVirtualBase1, public AddedVirtualBase2
        {
        public:
            BaseClassBecameVirtuallyInherited();
        };";
    $SOURCE2 .= "
        BaseClassBecameVirtuallyInherited::BaseClassBecameVirtuallyInherited() { }";

    # Added_Base_Class, Removed_Base_Class
    $HEADER1 .= "
        class $DECL_SPEC BaseClass
        {
        public:
            BaseClass();
            int method();
            double p[5];
        };
        class $DECL_SPEC RemovedBaseClass
        {
        public:
            RemovedBaseClass();
            int method();
        };
        class $DECL_SPEC ChangedBaseClass:public BaseClass, public RemovedBaseClass
        {
        public:
            ChangedBaseClass();
        };";
    $SOURCE1 .= "
        BaseClass::BaseClass() { }
        int BaseClass::method() { return 0; }
        RemovedBaseClass::RemovedBaseClass() { }
        int RemovedBaseClass::method() { return 0; }
        ChangedBaseClass::ChangedBaseClass() { }";

    $HEADER2 .= "
        class $DECL_SPEC BaseClass
        {
        public:
            BaseClass();
            int method();
            double p[5];
        };
        class $DECL_SPEC AddedBaseClass
        {
        public:
            AddedBaseClass();
            int method();
        };
        class $DECL_SPEC ChangedBaseClass:public BaseClass, public AddedBaseClass
        {
        public:
            ChangedBaseClass();
        };";
    $SOURCE2 .= "
        BaseClass::BaseClass() { }
        int BaseClass::method() { return 0; }
        AddedBaseClass::AddedBaseClass() { }
        int AddedBaseClass::method() { return 0; }
        ChangedBaseClass::ChangedBaseClass() { }";

    # Added_Base_Class_And_Shift, Removed_Base_Class_And_Shift
    $HEADER1 .= "
        struct $DECL_SPEC BaseClass2
        {
            BaseClass2();
            int method();
            double p[15];
        };
        class $DECL_SPEC ChangedBaseClassAndSize:public BaseClass
        {
        public:
            ChangedBaseClassAndSize();
        };";
    $SOURCE1 .= "
        BaseClass2::BaseClass2() { }
        int BaseClass2::method() { return 0; }
        ChangedBaseClassAndSize::ChangedBaseClassAndSize() { }";

    $HEADER2 .= "
        struct $DECL_SPEC BaseClass2
        {
            BaseClass2();
            int method();
            double p[15];
        };
        class $DECL_SPEC ChangedBaseClassAndSize:public BaseClass2
        {
        public:
            ChangedBaseClassAndSize();
        };";
    $SOURCE2 .= "
        BaseClass2::BaseClass2() { }
        int BaseClass2::method() { return 0; }
        ChangedBaseClassAndSize::ChangedBaseClassAndSize() { }";

    # Added_Field_And_Size
    $HEADER1 .= "
        struct $DECL_SPEC AddedFieldAndSize
        {
            int method(AddedFieldAndSize param);
            double i, j, k;
            AddedFieldAndSize* p;
        };";
    $SOURCE1 .= "
        int AddedFieldAndSize::method(AddedFieldAndSize param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC AddedFieldAndSize
        {
            int method(AddedFieldAndSize param);
            double i, j, k;
            AddedFieldAndSize* p;
            int added_member1;
            long long added_member2;
        };";
    $SOURCE2 .= "
        int AddedFieldAndSize::method(AddedFieldAndSize param) { return 0; }";

    # Added_Field
    $HEADER1 .= "
        class $DECL_SPEC ObjectAddedMember
        {
        public:
            int method(int param);
            double i, j, k;
            AddedFieldAndSize* p;
        };";
    $SOURCE1 .= "
        int ObjectAddedMember::method(int param) { return param; }";

    $HEADER2 .= "
        class $DECL_SPEC ObjectAddedMember
        {
        public:
            int method(int param);
            double i, j, k;
            AddedFieldAndSize* p;
            int added_member1;
            long long added_member2;
        };";
    $SOURCE2 .= "
        int ObjectAddedMember::method(int param) { return param; }";

    # Added_Field (safe)
    $HEADER1 .= "
        struct $DECL_SPEC AddedBitfield
        {
            int method(AddedBitfield param);
            double i, j, k;
            int b1 : 32;
            int b2 : 31;
            AddedBitfield* p;
        };";
    $SOURCE1 .= "
        int AddedBitfield::method(AddedBitfield param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC AddedBitfield
        {
            int method(AddedBitfield param);
            double i, j, k;
            int b1 : 32;
            int b2 : 31;
            int added_bitfield : 1;
            int added_bitfield2 : 1;
            AddedBitfield* p;
        };";
    $SOURCE2 .= "
        int AddedBitfield::method(AddedBitfield param) { return 0; }";

    # Bit_Field_Size
    $HEADER1 .= "
        struct $DECL_SPEC BitfieldSize
        {
            int method(BitfieldSize param);
            short changed_bitfield : 1;
        };";
    $SOURCE1 .= "
        int BitfieldSize::method(BitfieldSize param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC BitfieldSize
        {
            int method(BitfieldSize param);
            short changed_bitfield : 7;
        };";
    $SOURCE2 .= "
        int BitfieldSize::method(BitfieldSize param) { return 0; }";

    # Removed_Field
    $HEADER1 .= "
        struct $DECL_SPEC RemovedBitfield
        {
            int method(RemovedBitfield param);
            double i, j, k;
            int b1 : 32;
            int b2 : 31;
            int removed_bitfield : 1;
            RemovedBitfield* p;
        };";
    $SOURCE1 .= "
        int RemovedBitfield::method(RemovedBitfield param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC RemovedBitfield
        {
            int method(RemovedBitfield param);
            double i, j, k;
            int b1 : 32;
            int b2 : 31;
            RemovedBitfield* p;
        };";
    $SOURCE2 .= "
        int RemovedBitfield::method(RemovedBitfield param) { return 0; }";

    # Removed_Middle_Field
    $HEADER1 .= "
        struct $DECL_SPEC RemovedMiddleBitfield
        {
            int method(RemovedMiddleBitfield param);
            double i, j, k;
            int b1 : 32;
            int removed_middle_bitfield : 1;
            int b2 : 31;
            RemovedMiddleBitfield* p;
        };";
    $SOURCE1 .= "
        int RemovedMiddleBitfield::method(RemovedMiddleBitfield param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC RemovedMiddleBitfield
        {
            int method(RemovedMiddleBitfield param);
            double i, j, k;
            int b1 : 32;
            int b2 : 31;
            RemovedMiddleBitfield* p;
        };";
    $SOURCE2 .= "
        int RemovedMiddleBitfield::method(RemovedMiddleBitfield param) { return 0; }";

    # Added_Middle_Field_And_Size
    $HEADER1 .= "
        struct $DECL_SPEC AddedMiddleFieldAndSize
        {
            int method(AddedMiddleFieldAndSize param);
            int i;
            long j;
            double k;
            AddedMiddleFieldAndSize* p;
        };";
    $SOURCE1 .= "
        int AddedMiddleFieldAndSize::method(AddedMiddleFieldAndSize param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC AddedMiddleFieldAndSize
        {
            int method(AddedMiddleFieldAndSize param);
            int i;
            int added_middle_member;
            long j;
            double k;
            AddedMiddleFieldAndSize* p;
        };";
    $SOURCE2 .= "
        int AddedMiddleFieldAndSize::method(AddedMiddleFieldAndSize param) { return 0; }";

    # Added_Field (padding)
    $HEADER1 .= "
        struct $DECL_SPEC AddedMiddlePaddedField
        {
            int method(int param);
            short i;
            long j;
            double k;
        };";
    $SOURCE1 .= "
        int AddedMiddlePaddedField::method(int param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC AddedMiddlePaddedField
        {
            int method(int param);
            short i;
            short added_padded_field;
            long j;
            double k;
        };";
    $SOURCE2 .= "
        int AddedMiddlePaddedField::method(int param) { return 0; }";

    # Added_Field (tail padding)
    $HEADER1 .= "
        struct $DECL_SPEC AddedTailField
        {
            int method(int param);
            int i1, i2, i3, i4, i5, i6, i7;
            short s;
        };";
    $SOURCE1 .= "
        int AddedTailField::method(int param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC AddedTailField
        {
            int method(int param);
            int i1, i2, i3, i4, i5, i6, i7;
            short s;
            short added_tail_field;
        };";
    $SOURCE2 .= "
        int AddedTailField::method(int param) { return 0; }";

    # Test Alignment
    $HEADER1 .= "
        struct $DECL_SPEC TestAlignment
        {
            int method(int param);
            short s:9;
            short   j:9;
            char  c;
            short t:9;
            short u:9;
            char d;
        };";
    $SOURCE1 .= "
        int TestAlignment::method(int param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC TestAlignment
        {
            int method(int param);
            short s:9;
            short   j:9;
            char  c;
            short t:9;
            short u:9;
            char d;
        };";
    $SOURCE2 .= "
        int TestAlignment::method(int param) { return 0; }";

    # Renamed_Field
    $HEADER1 .= "
        struct $DECL_SPEC RenamedField
        {
            int method(RenamedField param);
            long i;
            long j;
            double k;
            RenamedField* p;
        };";
    $SOURCE1 .= "
        int RenamedField::method(RenamedField param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC RenamedField
        {
            int method(RenamedField param);
            long renamed_member;
            long j;
            double k;
            RenamedField* p;
        };";
    $SOURCE2 .= "
        int RenamedField::method(RenamedField param) { return 0; }";

    # Removed_Field_And_Size
    $HEADER1 .= "
        struct $DECL_SPEC RemovedFieldAndSize
        {
            int method(RemovedFieldAndSize param);
            double i, j, k;
            RemovedFieldAndSize* p;
            int removed_member1;
            long removed_member2;
        };";
    $SOURCE1 .= "
        int RemovedFieldAndSize::method(RemovedFieldAndSize param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC RemovedFieldAndSize
        {
            int method(RemovedFieldAndSize param);
            double i, j, k;
            RemovedFieldAndSize* p;
        };";
    $SOURCE2 .= "
        int RemovedFieldAndSize::method(RemovedFieldAndSize param) { return 0; }";

    # Field Position
    $HEADER1 .= "
        struct $DECL_SPEC MovedField
        {
            int method(int param);
            double i;
            int j;
        };";
    $SOURCE1 .= "
        int MovedField::method(int param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC MovedField
        {
            int method(int param);
            int j;
            double i;
        };";
    $SOURCE2 .= "
        int MovedField::method(int param) { return 0; }";

    # Removed_Middle_Field_And_Size
    $HEADER1 .= "
        struct $DECL_SPEC RemovedMiddleFieldAndSize
        {
            int method(RemovedMiddleFieldAndSize param);
            int i;
            int removed_middle_member;
            long j;
            double k;
            RemovedMiddleFieldAndSize* p;
        };";
    $SOURCE1 .= "
        int RemovedMiddleFieldAndSize::method(RemovedMiddleFieldAndSize param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC RemovedMiddleFieldAndSize
        {
            int method(RemovedMiddleFieldAndSize param);
            int i;
            long j;
            double k;
            RemovedMiddleFieldAndSize* p;
        };";
    $SOURCE2 .= "
        int RemovedMiddleFieldAndSize::method(RemovedMiddleFieldAndSize param) { return 0; }";

    # Enum_Member_Value
    $HEADER1 .= "
        enum EnumMemberValue
        {
            MEMBER_1=1,
            MEMBER_2=2
        };";
    $HEADER1 .= "
        $DECL_SPEC int enumMemberValueChange(enum EnumMemberValue param);";
    $SOURCE1 .= "
        int enumMemberValueChange(enum EnumMemberValue param) { return 0; }";

    $HEADER2 .= "
        enum EnumMemberValue
        {
            MEMBER_1=2,
            MEMBER_2=1
        };";
    $HEADER2 .= "
        $DECL_SPEC int enumMemberValueChange(enum EnumMemberValue param);";
    $SOURCE2 .= "
        int enumMemberValueChange(enum EnumMemberValue param) { return 0; }";

    # Enum_Member_Name
    $HEADER1 .= "
        enum EnumMemberRename
        {
            BRANCH_1=1,
            BRANCH_2=2
        };";
    $HEADER1 .= "
        $DECL_SPEC int enumMemberRename(enum EnumMemberRename param);";
    $SOURCE1 .= "
        int enumMemberRename(enum EnumMemberRename param) { return 0; }";

    $HEADER2 .= "
        enum EnumMemberRename
        {
            BRANCH_FIRST=1,
            BRANCH_SECOND=2
        };";
    $HEADER2 .= "
        $DECL_SPEC int enumMemberRename(enum EnumMemberRename param);";
    $SOURCE2 .= "
        int enumMemberRename(enum EnumMemberRename param) { return 0; }";

    # Field_Type_And_Size
    $HEADER1 .= "
        struct $DECL_SPEC FieldTypeAndSize
        {
            int method(FieldTypeAndSize param);
            int i;
            long j;
            double k;
            FieldTypeAndSize* p;
        };";
    $SOURCE1 .= "
        int FieldTypeAndSize::method(FieldTypeAndSize param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC FieldTypeAndSize
        {
            int method(FieldTypeAndSize param);
            long long i;
            long j;
            double k;
            FieldTypeAndSize* p;
        };";
    $SOURCE2 .= "
        int FieldTypeAndSize::method(FieldTypeAndSize param) { return 0; }";

    # Member_Type
    $HEADER1 .= "
        struct $DECL_SPEC MemberType
        {
            int method(MemberType param);
            int i;
            long j;
            double k;
            MemberType* p;
        };";
    $SOURCE1 .= "
        int MemberType::method(MemberType param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC MemberType
        {
            int method(MemberType param);
            float i;
            long j;
            double k;
            MemberType* p;
        };";
    $SOURCE2 .= "
        int MemberType::method(MemberType param) { return 0; }";

    # Field_BaseType
    $HEADER1 .= "
        struct $DECL_SPEC FieldBaseType
        {
            int method(FieldBaseType param);
            int *i;
            long j;
            double k;
            FieldBaseType* p;
        };";
    $SOURCE1 .= "
        int FieldBaseType::method(FieldBaseType param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC FieldBaseType
        {
            int method(FieldBaseType param);
            long long *i;
            long j;
            double k;
            FieldBaseType* p;
        };";
    $SOURCE2 .= "
        int FieldBaseType::method(FieldBaseType param) { return 0; }";

    # Field_PointerLevel_Increased (and size)
    $HEADER1 .= "
        struct $DECL_SPEC FieldPointerLevelAndSize
        {
            int method(FieldPointerLevelAndSize param);
            long long i;
            long j;
            double k;
            FieldPointerLevelAndSize* p;
        };";
    $SOURCE1 .= "
        int FieldPointerLevelAndSize::method(FieldPointerLevelAndSize param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC FieldPointerLevelAndSize
        {
            int method(FieldPointerLevelAndSize param);
            long long *i;
            long j;
            double k;
            FieldPointerLevelAndSize* p;
        };";
    $SOURCE2 .= "
        int FieldPointerLevelAndSize::method(FieldPointerLevelAndSize param) { return 0; }";

    # Field_PointerLevel
    $HEADER1 .= "
        struct $DECL_SPEC FieldPointerLevel
        {
            int method(FieldPointerLevel param);
            int **i;
            long j;
            double k;
            FieldPointerLevel* p;
        };";
    $SOURCE1 .= "
        int FieldPointerLevel::method(FieldPointerLevel param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC FieldPointerLevel
        {
            int method(FieldPointerLevel param);
            int *i;
            long j;
            double k;
            FieldPointerLevel* p;
        };";
    $SOURCE2 .= "
        int FieldPointerLevel::method(FieldPointerLevel param) { return 0; }";

    # Added_Interface (method)
    $HEADER1 .= "
        struct $DECL_SPEC AddedInterface
        {
            int method(AddedInterface param);
            int i;
            long j;
            double k;
            AddedInterface* p;
        };";
    $SOURCE1 .= "
        int AddedInterface::method(AddedInterface param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC AddedInterface
        {
            int method(AddedInterface param);
            int added_func(AddedInterface param);
            int i;
            long j;
            double k;
            AddedInterface* p;
        };";
    $SOURCE2 .= "
        int AddedInterface::method(AddedInterface param) { return 0; }";
    $SOURCE2 .= "
        int AddedInterface::added_func(AddedInterface param) { return 0; }";

    # Added_Interface (function)
    $HEADER2 .= "
        $DECL_SPEC int addedFunc2(void *** param);";
    $SOURCE2 .= "
        int addedFunc2(void *** param) { return 0; }";

    # Added_Interface (global variable)
    $HEADER1 .= "
        struct $DECL_SPEC AddedVariable
        {
            int method(AddedVariable param);
            int i1, i2;
            long j;
            double k;
            AddedVariable* p;
        };";
    $SOURCE1 .= "
        int AddedVariable::method(AddedVariable param) {
            return i1;
        }";

    $HEADER2 .= "
        struct $DECL_SPEC AddedVariable
        {
            int method(AddedVariable param);
            static int i1;
            static int i2;
            long j;
            double k;
            AddedVariable* p;
        };";
    $SOURCE2 .= "
        int AddedVariable::method(AddedVariable param) { return AddedVariable::i1; }";
    $SOURCE2 .= "
        int AddedVariable::i1=0;";
    $SOURCE2 .= "
        int AddedVariable::i2=0;";

    # Removed_Interface (method)
    $HEADER1 .= "
        struct $DECL_SPEC RemovedInterface
        {
            int method(RemovedInterface param);
            int removed_func(RemovedInterface param);
            int i;
            long j;
            double k;
            RemovedInterface* p;
        };";
    $SOURCE1 .= "
        int RemovedInterface::method(RemovedInterface param) { return 0; }";
    $SOURCE1 .= "
        int RemovedInterface::removed_func(RemovedInterface param) { return 0; }";

    $HEADER2 .= "
        struct $DECL_SPEC RemovedInterface
        {
            int method(RemovedInterface param);
            int i;
            long j;
            double k;
            RemovedInterface* p;
        };";
    $SOURCE2 .= "
        int RemovedInterface::method(RemovedInterface param) { return 0; }";

    # Removed_Interface (function)
    $HEADER1 .= "
        $DECL_SPEC int removedFunc2(void *** param);";
    $SOURCE1 .= "
        int removedFunc2(void *** param) { return 0; }";

    # Method_Became_Static
    $HEADER1 .= "
        struct $DECL_SPEC MethodBecameStatic
        {
            MethodBecameStatic becameStatic(MethodBecameStatic param);
            int **i;
            long j;
            double k;
            MethodBecameStatic* p;
        };";
    $SOURCE1 .= "
        MethodBecameStatic MethodBecameStatic::becameStatic(MethodBecameStatic param) { return param; }";

    $HEADER2 .= "
        struct $DECL_SPEC MethodBecameStatic
        {
            static MethodBecameStatic becameStatic(MethodBecameStatic param);
            int **i;
            long j;
            double k;
            MethodBecameStatic* p;
        };";
    $SOURCE2 .= "
        MethodBecameStatic MethodBecameStatic::becameStatic(MethodBecameStatic param) { return param; }";

    # Method_Became_Non_Static
    $HEADER1 .= "
        struct $DECL_SPEC MethodBecameNonStatic
        {
            static MethodBecameNonStatic becameNonStatic(MethodBecameNonStatic param);
            int **i;
            long j;
            double k;
            MethodBecameNonStatic* p;
        };";
    $SOURCE1 .= "
        MethodBecameNonStatic MethodBecameNonStatic::becameNonStatic(MethodBecameNonStatic param) { return param; }";

    $HEADER2 .= "
        struct $DECL_SPEC MethodBecameNonStatic
        {
            MethodBecameNonStatic becameNonStatic(MethodBecameNonStatic param);
            int **i;
            long j;
            double k;
            MethodBecameNonStatic* p;
        };";
    $SOURCE2 .= "
        MethodBecameNonStatic MethodBecameNonStatic::becameNonStatic(MethodBecameNonStatic param) { return param; }";

    # Parameter_Type_And_Size
    $HEADER1 .= "
        $DECL_SPEC int funcParameterTypeAndSize(int param, int other_param);";
    $SOURCE1 .= "
        int funcParameterTypeAndSize(int param, int other_param) { return other_param; }";

    $HEADER2 .= "
        $DECL_SPEC int funcParameterTypeAndSize(long long param, int other_param);";
    $SOURCE2 .= "
        int funcParameterTypeAndSize(long long param, int other_param) { return other_param; }";

    # Parameter_Type
    $HEADER1 .= "
        $DECL_SPEC int funcParameterType(int param, int other_param);";
    $SOURCE1 .= "
        int funcParameterType(int param, int other_param) { return other_param; }";

    $HEADER2 .= "
        $DECL_SPEC int funcParameterType(float param, int other_param);";
    $SOURCE2 .= "
        int funcParameterType(float param, int other_param) { return other_param; }";

    # Parameter_BaseType
    $HEADER1 .= "
        $DECL_SPEC int funcParameterBaseType(int *param);";
    $SOURCE1 .= "
        int funcParameterBaseType(int *param) { return sizeof(*param); }";

    $HEADER2 .= "
        $DECL_SPEC int funcParameterBaseType(long long *param);";
    $SOURCE2 .= "
        int funcParameterBaseType(long long *param) { return sizeof(*param); }";

    # Parameter_PointerLevel
    $HEADER1 .= "
        $DECL_SPEC long long funcParameterPointerLevelAndSize(long long param);";
    $SOURCE1 .= "
        long long funcParameterPointerLevelAndSize(long long param) { return param; }";

    $HEADER2 .= "
        $DECL_SPEC long long funcParameterPointerLevelAndSize(long long *param);";
    $SOURCE2 .= "
        long long funcParameterPointerLevelAndSize(long long *param) { return param[5]; }";

    # Parameter_PointerLevel
    $HEADER1 .= "
        $DECL_SPEC int funcParameterPointerLevel(int *param);";
    $SOURCE1 .= "
        int funcParameterPointerLevel(int *param) { return param[5]; }";

    $HEADER2 .= "
        $DECL_SPEC int funcParameterPointerLevel(int **param);";
    $SOURCE2 .= "
        int funcParameterPointerLevel(int **param) { return param[5][5]; }";

    # Return_Type_And_Size
    $HEADER1 .= "
        $DECL_SPEC int funcReturnTypeAndSize(int param);";
    $SOURCE1 .= "
        int funcReturnTypeAndSize(int param) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC long long funcReturnTypeAndSize(int param);";
    $SOURCE2 .= "
        long long funcReturnTypeAndSize(int param) { return 0; }";

    # Return_Type
    $HEADER1 .= "
        $DECL_SPEC int funcReturnType(int param);";
    $SOURCE1 .= "
        int funcReturnType(int param) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC float funcReturnType(int param);";
    $SOURCE2 .= "
        float funcReturnType(int param) { return 0.7; }";

    # Return_Type_Became_Void ("int" to "void")
    $HEADER1 .= "
        $DECL_SPEC int funcReturnTypeBecameVoid(int param);";
    $SOURCE1 .= "
        int funcReturnTypeBecameVoid(int param) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC void funcReturnTypeBecameVoid(int param);";
    $SOURCE2 .= "
        void funcReturnTypeBecameVoid(int param) { return; }";

    # Return_BaseType
    $HEADER1 .= "
        $DECL_SPEC int* funcReturnBaseType(int param);";
    $SOURCE1 .= "
        int* funcReturnBaseType(int param) {
            int *x = new int[10];
            return x;
        }";

    $HEADER2 .= "
        $DECL_SPEC long long* funcReturnBaseType(int param);";
    $SOURCE2 .= "
        long long* funcReturnBaseType(int param) {
            long long *x = new long long[10];
            return x;
        }";

    # Return_PointerLevel
    $HEADER1 .= "
        $DECL_SPEC long long funcReturnPointerLevelAndSize(int param);";
    $SOURCE1 .= "
        long long funcReturnPointerLevelAndSize(int param) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC long long* funcReturnPointerLevelAndSize(int param);";
    $SOURCE2 .= "
        long long* funcReturnPointerLevelAndSize(int param) { return new long long[10]; }";

    # Return_PointerLevel
    $HEADER1 .= "
        $DECL_SPEC int* funcReturnPointerLevel(int param);";
    $SOURCE1 .= "
        int* funcReturnPointerLevel(int param) { return new int[10]; }";

    $HEADER2 .= "
        $DECL_SPEC int** funcReturnPointerLevel(int param);";
    $SOURCE2 .= "
        int** funcReturnPointerLevel(int param) { return new int*[10]; }";

    # Size (anon type)
    $HEADER1 .= "
        typedef struct {
            int i;
            long j;
            double k;
        } AnonTypedef;
        $DECL_SPEC int funcAnonTypedef(AnonTypedef param);";
    $SOURCE1 .= "
        int funcAnonTypedef(AnonTypedef param) { return 0; }";

    $HEADER2 .= "
        typedef struct {
            int i;
            long j;
            double k;
            union {
                int dummy[256];
                struct {
                    char q_skiptable[256];
                    const char *p;
                    int l;
                } p;
            };
        } AnonTypedef;
        $DECL_SPEC int funcAnonTypedef(AnonTypedef param);";
    $SOURCE2 .= "
        int funcAnonTypedef(AnonTypedef param) { return 0; }";

    # Added_Field (safe: opaque)
    $HEADER1 .= "
        struct $DECL_SPEC OpaqueType
        {
        public:
            OpaqueType method(OpaqueType param);
            int i;
            long j;
            double k;
            OpaqueType* p;
        };";
    $SOURCE1 .= "
        OpaqueType OpaqueType::method(OpaqueType param) { return param; }";

    $HEADER2 .= "
        struct $DECL_SPEC OpaqueType
        {
        public:
            OpaqueType method(OpaqueType param);
            int i;
            long j;
            double k;
            OpaqueType* p;
            int added_member;
        };";
    $SOURCE2 .= "
        OpaqueType OpaqueType::method(OpaqueType param) { return param; }";

    # Added_Field (safe: internal)
    $HEADER1 .= "
        struct $DECL_SPEC InternalType {
            InternalType method(InternalType param);
            int i;
            long j;
            double k;
            InternalType* p;
        };";
    $SOURCE1 .= "
        InternalType InternalType::method(InternalType param) { return param; }";

    $HEADER2 .= "
        struct $DECL_SPEC InternalType {
            InternalType method(InternalType param);
            int i;
            long j;
            double k;
            InternalType* p;
            int added_member;
        };";
    $SOURCE2 .= "
        InternalType InternalType::method(InternalType param) { return param; }";

    # Size (unnamed struct/union fields within structs/unions)
    $HEADER1 .= "
        typedef struct {
            int a;
            struct {
                int u1;
                float u2;
            };
            int d;
        } UnnamedTypeSize;
        $DECL_SPEC int unnamedTypeSize(UnnamedTypeSize param);";
    $SOURCE1 .= "
        int unnamedTypeSize(UnnamedTypeSize param) { return 0; }";

    $HEADER2 .= "
        typedef struct {
            int a;
            struct {
                long double u1;
                float u2;
            };
            int d;
        } UnnamedTypeSize;
        $DECL_SPEC int unnamedTypeSize(UnnamedTypeSize param);";
    $SOURCE2 .= "
        int unnamedTypeSize(UnnamedTypeSize param) { return 0; }";

    # Changed_Constant
    $HEADER1 .= "
        #define PUBLIC_CONSTANT \"old_value\"";
    $HEADER2 .= "
        #define PUBLIC_CONSTANT \"new_value\"";

    $HEADER1 .= "
        #define PUBLIC_VERSION \"1.2 (3.4)\"";
    $HEADER2 .= "
        #define PUBLIC_VERSION \"1.2 (3.5)\"";

    $HEADER1 .= "
        #define PRIVATE_CONSTANT \"old_value\"
        #undef PRIVATE_CONSTANT";
    $HEADER2 .= "
        #define PRIVATE_CONSTANT \"new_value\"
        #undef PRIVATE_CONSTANT";

    # Added_Field (union)
    $HEADER1 .= "
        union UnionAddedField {
            int a;
            struct {
                int b;
                float c;
            };
            int d;
        };
        $DECL_SPEC int unionAddedField(UnionAddedField param);";
    $SOURCE1 .= "
        int unionAddedField(UnionAddedField param) { return 0; }";

    $HEADER2 .= "
        union UnionAddedField {
            int a;
            struct {
                long double x, y;
            } new_field;
            struct {
                int b;
                float c;
            };
            int d;
        };
        $DECL_SPEC int unionAddedField(UnionAddedField param);";
    $SOURCE2 .= "
        int unionAddedField(UnionAddedField param) { return 0; }";

    # Removed_Field (union)
    $HEADER1 .= "
        union UnionRemovedField {
            int a;
            struct {
                long double x, y;
            } removed_field;
            struct {
                int b;
                float c;
            };
            int d;
        };
        $DECL_SPEC int unionRemovedField(UnionRemovedField param);";
    $SOURCE1 .= "
        int unionRemovedField(UnionRemovedField param) { return 0; }";

    $HEADER2 .= "
        union UnionRemovedField {
            int a;
            struct {
                int b;
                float c;
            };
            int d;
        };
        $DECL_SPEC int unionRemovedField(UnionRemovedField param);";
    $SOURCE2 .= "
        int unionRemovedField(UnionRemovedField param) { return 0; }";

    # Added (typedef change)
    $HEADER1 .= "
        typedef float TYPEDEF_TYPE;
        $DECL_SPEC int parameterTypedefChange(TYPEDEF_TYPE param);";
    $SOURCE1 .= "
        int parameterTypedefChange(TYPEDEF_TYPE param) { return 1; }";

    $HEADER2 .= "
        typedef int TYPEDEF_TYPE;
        $DECL_SPEC int parameterTypedefChange(TYPEDEF_TYPE param);";
    $SOURCE2 .= "
        int parameterTypedefChange(TYPEDEF_TYPE param) { return 1; }";

    # Parameter_Default_Value_Changed (safe)
    # Converted from void* to const char*
    $HEADER1 .= "
        $DECL_SPEC int paramDefaultValue_Converted(const char* arg = 0); ";
    $SOURCE1 .= "
        int paramDefaultValue_Converted(const char* arg) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC int paramDefaultValue_Converted(const char* arg = (const char*)((void*) 0)); ";
    $SOURCE2 .= "
        int paramDefaultValue_Converted(const char* arg) { return 0; }";

    # Parameter_Default_Value_Changed
    # Integer
    $HEADER1 .= "
        $DECL_SPEC int paramDefaultValueChanged_Integer(int param = 0xf00f); ";
    $SOURCE1 .= "
        int paramDefaultValueChanged_Integer(int param) { return param; }";

    $HEADER2 .= "
        $DECL_SPEC int paramDefaultValueChanged_Integer(int param = 0xf00b); ";
    $SOURCE2 .= "
        int paramDefaultValueChanged_Integer(int param) { return param; }";

    # Parameter_Default_Value_Changed
    # String
    $HEADER1 .= "
        $DECL_SPEC int paramDefaultValueChanged_String(char const* param = \" str  1 \"); ";
    $SOURCE1 .= "
        int paramDefaultValueChanged_String(char const* param) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC int paramDefaultValueChanged_String(char const* param = \" str  2 \"); ";
    $SOURCE2 .= "
        int paramDefaultValueChanged_String(char const* param) { return 0; }";

    # Parameter_Default_Value_Changed
    # Character
    $HEADER1 .= "
        $DECL_SPEC int paramDefaultValueChanged_Char(char param = \'A\'); ";
    $SOURCE1 .= "
        int paramDefaultValueChanged_Char(char param) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC int paramDefaultValueChanged_Char(char param = \'B\'); ";
    $SOURCE2 .= "
        int paramDefaultValueChanged_Char(char param) { return 0; }";

    # Parameter_Default_Value_Changed
    # Bool
    $HEADER1 .= "
        $DECL_SPEC int paramDefaultValueChanged_Bool(bool param = true); ";
    $SOURCE1 .= "
        int paramDefaultValueChanged_Bool(bool param) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC int paramDefaultValueChanged_Bool(bool param = false); ";
    $SOURCE2 .= "
        int paramDefaultValueChanged_Bool(bool param) { return 0; }";

    # Parameter_Default_Value_Removed
    $HEADER1 .= "
        $DECL_SPEC int parameterDefaultValueRemoved(int param = 15);
    ";
    $SOURCE1 .= "
        int parameterDefaultValueRemoved(int param) { return param; }";

    $HEADER2 .= "
        $DECL_SPEC int parameterDefaultValueRemoved(int param);";
    $SOURCE2 .= "
        int parameterDefaultValueRemoved(int param) { return param; }";

    # Parameter_Default_Value_Added
    $HEADER1 .= "
        $DECL_SPEC int parameterDefaultValueAdded(int param);
    ";
    $SOURCE1 .= "
        int parameterDefaultValueAdded(int param) { return param; }";

    $HEADER2 .= "
        $DECL_SPEC int parameterDefaultValueAdded(int param = 15);";
    $SOURCE2 .= "
        int parameterDefaultValueAdded(int param) { return param; }";

    # Field_Type (typedefs in member type)
    $HEADER1 .= "
        typedef float TYPEDEF_TYPE_2;
        struct $DECL_SPEC FieldTypedefChange{
        public:
            TYPEDEF_TYPE_2 m;
            TYPEDEF_TYPE_2 n;
        };
        $DECL_SPEC int fieldTypedefChange(FieldTypedefChange param);";
    $SOURCE1 .= "
        int fieldTypedefChange(FieldTypedefChange param) { return 1; }";

    $HEADER2 .= "
        typedef int TYPEDEF_TYPE_2;
        struct $DECL_SPEC FieldTypedefChange{
        public:
            TYPEDEF_TYPE_2 m;
            TYPEDEF_TYPE_2 n;
        };
        $DECL_SPEC int fieldTypedefChange(FieldTypedefChange param);";
    $SOURCE2 .= "
        int fieldTypedefChange(FieldTypedefChange param) { return 1; }";

    # Callback (testCallback symbol should be affected
    # instead of callback1 and callback2)
    $HEADER1 .= "
        class $DECL_SPEC Callback {
        public:
            virtual int callback1(int x, int y)=0;
            virtual int callback2(int x, int y)=0;
        };
        $DECL_SPEC int testCallback(Callback* p);";
    $SOURCE1 .= "
        int testCallback(Callback* p) {
            p->callback2(1, 2);
            return 0;
        }";

    $HEADER2 .= "
        class $DECL_SPEC Callback {
        public:
            virtual int callback1(int x, int y)=0;
            virtual int added_callback(int x, int y)=0;
            virtual int callback2(int x, int y)=0;
        };
        $DECL_SPEC int testCallback(Callback* p);";
    $SOURCE2 .= "
        int testCallback(Callback* p) {
            p->callback2(1, 2);
            return 0;
        }";

    # End namespace
    $HEADER1 .= "\n}\n";
    $HEADER2 .= "\n}\n";
    $SOURCE1 .= "\n}\n";
    $SOURCE2 .= "\n}\n";

    runTests("libsample_cpp", "C++", $HEADER1, $SOURCE1, $HEADER2, $SOURCE2, "TestNS::OpaqueType", "_ZN6TestNS12InternalType6methodES0_");
}

sub testC()
{
    printMsg("INFO", "\nverifying detectable C library changes");
    my ($HEADER1, $SOURCE1, $HEADER2, $SOURCE2) = ();
    my $DECL_SPEC = ($OSgroup eq "windows")?"__declspec( dllexport )":"";
    my $EXTERN = ($OSgroup eq "windows")?"extern ":""; # add "extern" for CL compiler

    # Struct to union
    $HEADER1 .= "
        typedef struct StructToUnion {
            unsigned char A[64];
        } StructToUnion;

        $DECL_SPEC int structToUnion(StructToUnion *p);";
    $SOURCE1 .= "
        int structToUnion(StructToUnion *p) { return 0; }";

    $HEADER2 .= "
        typedef union StructToUnion {
            unsigned char A[64];
            void *p;
        } StructToUnion;

        $DECL_SPEC int structToUnion(StructToUnion *p);";
    $SOURCE2 .= "
        int structToUnion(StructToUnion *p) { return 0; }";

    # Typedef to function
    $HEADER1 .= "
        typedef int(TypedefToFunction)(int pX);

        $DECL_SPEC int typedefToFunction(TypedefToFunction* p);";
    $SOURCE1 .= "
        int typedefToFunction(TypedefToFunction* p) { return 0; }";

    $HEADER2 .= "
        typedef int(TypedefToFunction)(int pX, int pY);

        $DECL_SPEC int typedefToFunction(TypedefToFunction* p);";
    $SOURCE2 .= "
        int typedefToFunction(TypedefToFunction* p) { return 0; }";

    # Used_Reserved
    $HEADER1 .= "
        typedef struct {
            int f;
            void* reserved0;
            void* reserved1;
        } UsedReserved;

        $DECL_SPEC int usedReserved(UsedReserved p);";
    $SOURCE1 .= "
        int usedReserved(UsedReserved p) { return 0; }";

    $HEADER2 .= "
        typedef struct {
            int f;
            void* f0;
            void* f1;
        } UsedReserved;

        $DECL_SPEC int usedReserved(UsedReserved p);";
    $SOURCE2 .= "
        int usedReserved(UsedReserved p) { return 0; }";

    # Parameter_Type_And_Register
    $HEADER1 .= "
        typedef struct {
            int a[4];
        } ARRAY;
        $DECL_SPEC void callConv5 (ARRAY i, int j);";
    $SOURCE1 .= "
        void callConv5 (ARRAY i, int j) { }";

    $HEADER2 .= "
        typedef struct {
            int a[4];
        } ARRAY;
        $DECL_SPEC void callConv5 (ARRAY i, double j);";
    $SOURCE2 .= "
        void callConv5 (ARRAY i, double j) { }";

    # Parameter_Type_And_Register
    $HEADER1 .= "
        typedef union {
            int a;
            double b;
        } UNION;
        $DECL_SPEC void callConv4 (UNION i, int j);";
    $SOURCE1 .= "
        void callConv4 (UNION i, int j) { }";

    $HEADER2 .= "
        typedef union {
            int a;
            double b;
        } UNION;
        $DECL_SPEC void callConv4 (UNION i, double j);";
    $SOURCE2 .= "
        void callConv4 (UNION i, double j) { }";

    # Parameter_Type_And_Register
    $HEADER1 .= "
        typedef struct {
            long a:4;
            long b:16;
        } POD2;
        $DECL_SPEC void callConv3 (POD2 i, int j);";
    $SOURCE1 .= "
        void callConv3 (POD2 i, int j) { }";

    $HEADER2 .= "
        typedef struct {
            long a:4;
            long b:16;
        } POD2;
        $DECL_SPEC void callConv3 (POD2 i, double j);";
    $SOURCE2 .= "
        void callConv3 (POD2 i, double j) { }";

    # Parameter_Type_And_Register
    $HEADER1 .= "
        typedef struct {
            short s:9;
            int j:9;
            char c;
            short t:9;
            short u:9;
            char d;
        } POD;
        $DECL_SPEC void callConv2 (POD i, int j);";
    $SOURCE1 .= "
        void callConv2 (POD i, int j) { }";

    $HEADER2 .= "
        typedef struct {
            short s:9;
            int j:9;
            char c;
            short t:9;
            short u:9;
            char d;
        } POD;
        $DECL_SPEC void callConv2 (POD i, double j);";
    $SOURCE2 .= "
        void callConv2 (POD i, double j) { }";

    # Parameter_Type_And_Register
    $HEADER1 .= "
        typedef struct {
            int a, b;
            double d;
        } POD1;
        $DECL_SPEC void callConv (int e, int f, POD1 s, int g, int h, long double ld, double m, double n, int i, int j, int k);";
    $SOURCE1 .= "
        void callConv(int e, int f, POD1 s, int g, int h, long double ld, double m, double n, int i, int j, int k) { }";

    $HEADER2 .= "
        typedef struct {
            int a, b;
            double d;
        } POD1;
        $DECL_SPEC void callConv (int e, int f, POD1 s, int g, int h, long double ld, double m, double n, int i, int j, double k);";
    $SOURCE2 .= "
        void callConv(int e, int f, POD1 s, int g, int h, long double ld, double m, double n, int i, int j, double k) { }";

    # Parameter_Type (int to "int const")
    $HEADER1 .= "
        $DECL_SPEC void parameterBecameConstInt(int arg);";
    $SOURCE1 .= "
        void parameterBecameConstInt(int arg) { }";

    $HEADER2 .= "
        $DECL_SPEC void parameterBecameConstInt(const int arg);";
    $SOURCE2 .= "
        void parameterBecameConstInt(const int arg) { }";

    # Parameter_Type ("int const" to int)
    $HEADER1 .= "
        $DECL_SPEC void parameterBecameNonConstInt(const int arg);";
    $SOURCE1 .= "
        void parameterBecameNonConstInt(const int arg) { }";

    $HEADER2 .= "
        $DECL_SPEC void parameterBecameNonConstInt(int arg);";
    $SOURCE2 .= "
        void parameterBecameNonConstInt(int arg) { }";

    # Parameter_Became_Register
    $HEADER1 .= "
        $DECL_SPEC void parameterBecameRegister(int arg);";
    $SOURCE1 .= "
        void parameterBecameRegister(int arg) { }";

    $HEADER2 .= "
        $DECL_SPEC void parameterBecameRegister(register int arg);";
    $SOURCE2 .= "
        void parameterBecameRegister(register int arg) { }";

    # Return_Type_Became_Const
    $HEADER1 .= "
        $DECL_SPEC char* returnTypeBecameConst(int param);";
    $SOURCE1 .= "
        char* returnTypeBecameConst(int param) { return (char*)malloc(256); }";

    $HEADER2 .= "
        $DECL_SPEC const char* returnTypeBecameConst(int param);";
    $SOURCE2 .= "
        const char* returnTypeBecameConst(int param) { return \"abc\"; }";

    # Return_Type_Became_Const (2)
    $HEADER1 .= "
        $DECL_SPEC char* returnTypeBecameConst2(int param);";
    $SOURCE1 .= "
        char* returnTypeBecameConst2(int param) { return (char*)malloc(256); }";

    $HEADER2 .= "
        $DECL_SPEC char*const returnTypeBecameConst2(int param);";
    $SOURCE2 .= "
        char*const returnTypeBecameConst2(int param) { return (char*const)malloc(256); }";

    # Return_Type_Became_Const (3)
    $HEADER1 .= "
        $DECL_SPEC char* returnTypeBecameConst3(int param);";
    $SOURCE1 .= "
        char* returnTypeBecameConst3(int param) { return (char*)malloc(256); }";

    $HEADER2 .= "
        $DECL_SPEC char const*const returnTypeBecameConst3(int param);";
    $SOURCE2 .= "
        char const*const returnTypeBecameConst3(int param) { return (char const*const)malloc(256); }";

    # Return_Type_Became_Volatile
    $HEADER1 .= "
        $DECL_SPEC char* returnTypeBecameVolatile(int param);";
    $SOURCE1 .= "
        char* returnTypeBecameVolatile(int param) { return (char*)malloc(256); }";

    $HEADER2 .= "
        $DECL_SPEC volatile char* returnTypeBecameVolatile(int param);";
    $SOURCE2 .= "
        volatile char* returnTypeBecameVolatile(int param) { return \"abc\"; }";

    # Added_Enum_Member
    $HEADER1 .= "
        enum AddedEnumMember {
            OldMember
        };
        $DECL_SPEC int addedEnumMember(enum AddedEnumMember param);";
    $SOURCE1 .= "
        int addedEnumMember(enum AddedEnumMember param) { return 0; }";

    $HEADER2 .= "
        enum AddedEnumMember {
            OldMember,
            NewMember
        };
        $DECL_SPEC int addedEnumMember(enum AddedEnumMember param);";
    $SOURCE2 .= "
        int addedEnumMember(enum AddedEnumMember param) { return 0; }";

    # Parameter_Type (Array)
    $HEADER1 .= "
        $DECL_SPEC int arrayParameterType(int param[5]);";
    $SOURCE1 .= "
        int arrayParameterType(int param[5]) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC int arrayParameterType(int param[7]);";
    $SOURCE2 .= "
        int arrayParameterType(int param[7]) { return 0; }";

    # Field_Type
    $HEADER1 .= "
        struct ArrayFieldType
        {
            int f;
            int i[1];
        };
        $DECL_SPEC int arrayFieldType(struct ArrayFieldType param);";
    $SOURCE1 .= "
        int arrayFieldType(struct ArrayFieldType param) { return param.i[0]; }";

    $HEADER2 .= "
        struct ArrayFieldType
        {
            int f;
            int i[];
        };
        $DECL_SPEC int arrayFieldType(struct ArrayFieldType param);";
    $SOURCE2 .= "
        int arrayFieldType(struct ArrayFieldType param) { return param.i[0]; }";

    # Field_Type_And_Size (Array)
    $HEADER1 .= "
        struct ArrayFieldSize
        {
            int i[5];
        };
        $DECL_SPEC int arrayFieldSize(struct ArrayFieldSize param);";
    $SOURCE1 .= "
        int arrayFieldSize(struct ArrayFieldSize param) { return 0; }";

    $HEADER2 .= "
        struct ArrayFieldSize
        {
            int i[7];
        };
        $DECL_SPEC int arrayFieldSize(struct ArrayFieldSize param);";
    $SOURCE2 .= "
        int arrayFieldSize(struct ArrayFieldSize param) { return 0; }";

    # Parameter_Became_Non_VaList
    $HEADER1 .= "
        $DECL_SPEC int parameterNonVaList(int param, ...);";
    $SOURCE1 .= "
        int parameterNonVaList(int param, ...) { return param; }";

    $HEADER2 .= "
        $DECL_SPEC int parameterNonVaList(int param1, int param2);";
    $SOURCE2 .= "
        int parameterNonVaList(int param1, int param2) { return param1; }";

    # Parameter_Became_VaList
    $HEADER1 .= "
        $DECL_SPEC int parameterVaList(int param1, int param2);";
    $SOURCE1 .= "
        int parameterVaList(int param1, int param2) { return param1; }";

    $HEADER2 .= "
        $DECL_SPEC int parameterVaList(int param, ...);";
    $SOURCE2 .= "
        int parameterVaList(int param, ...) { return param; }";

    # Field_Type_And_Size
    $HEADER1 .= "
        struct FieldSizePadded
        {
            int i;
            char changed_field;
            // padding (3 bytes)
            int j;
        };
        $DECL_SPEC int fieldSizePadded(struct FieldSizePadded param);";
    $SOURCE1 .= "
        int fieldSizePadded(struct FieldSizePadded param) { return 0; }";

    $HEADER2 .= "
        struct FieldSizePadded
        {
            int i;
            int changed_field;
            int j;
        };
        $DECL_SPEC int fieldSizePadded(struct FieldSizePadded param);";
    $SOURCE2 .= "
        int fieldSizePadded(struct FieldSizePadded param) { return 0; }";

    # Parameter_Type_Format
    $HEADER1 .= "
        struct DType1
        {
            int i;
            double j[7];
        };
        $DECL_SPEC int parameterTypeFormat(struct DType1 param);";
    $SOURCE1 .= "
        int parameterTypeFormat(struct DType1 param) { return 0; }";

    $HEADER2 .= "
        struct DType2
        {
            double i[7];
            int j;
        };
        $DECL_SPEC int parameterTypeFormat(struct DType2 param);";
    $SOURCE2 .= "
        int parameterTypeFormat(struct DType2 param) { return 0; }";

    # Field_Type_Format
    $HEADER1 .= "
        struct FieldTypeFormat
        {
            int i;
            struct DType1 j;
        };
        $DECL_SPEC int fieldTypeFormat(struct FieldTypeFormat param);";
    $SOURCE1 .= "
        int fieldTypeFormat(struct FieldTypeFormat param) { return 0; }";

    $HEADER2 .= "
        struct FieldTypeFormat
        {
            int i;
            struct DType2 j;
        };
        $DECL_SPEC int fieldTypeFormat(struct FieldTypeFormat param);";
    $SOURCE2 .= "
        int fieldTypeFormat(struct FieldTypeFormat param) { return 0; }";

    # Parameter_Type_Format (struct to union)
    $HEADER1 .= "
        struct DType
        {
            int i;
            double j;
        };
        $DECL_SPEC int parameterTypeFormat2(struct DType param);";
    $SOURCE1 .= "
        int parameterTypeFormat2(struct DType param) { return 0; }";

    $HEADER2 .= "
        union DType
        {
            int i;
            long double j;
        };
        $DECL_SPEC int parameterTypeFormat2(union DType param);";
    $SOURCE2 .= "
        int parameterTypeFormat2(union DType param) { return 0; }";

    # Global_Data_Size
    $HEADER1 .= "
        struct GlobalDataSize {
            int a;
        };
        $EXTERN $DECL_SPEC struct GlobalDataSize globalDataSize;";

    $HEADER2 .= "
        struct GlobalDataSize {
            int a, b;
        };
        $EXTERN $DECL_SPEC struct GlobalDataSize globalDataSize;";

    # Global_Data_Type
    $HEADER1 .= "
        $EXTERN $DECL_SPEC int globalDataType;";

    $HEADER2 .= "
        $EXTERN $DECL_SPEC float globalDataType;";

    # Global_Data_Type_And_Size
    $HEADER1 .= "
        $EXTERN $DECL_SPEC int globalDataTypeAndSize;";

    $HEADER2 .= "
        $EXTERN $DECL_SPEC short globalDataTypeAndSize;";

    # Global_Data_Value_Changed
    # Integer
    $HEADER1 .= "
        $EXTERN $DECL_SPEC const int globalDataValue_Integer = 10;";

    $HEADER2 .= "
        $EXTERN $DECL_SPEC const int globalDataValue_Integer = 15;";

    # Global_Data_Value_Changed
    # Character
    $HEADER1 .= "
        $EXTERN $DECL_SPEC const char globalDataValue_Char = \'o\';";

    $HEADER2 .= "
        $EXTERN $DECL_SPEC const char globalDataValue_Char = \'N\';";

    # Global_Data_Became_Non_Const
    $HEADER1 .= "
        $EXTERN $DECL_SPEC const int globalDataBecameNonConst = 10;";

    $HEADER2 .= "
        extern $DECL_SPEC int globalDataBecameNonConst;";
    $SOURCE2 .= "
        int globalDataBecameNonConst = 15;";

    # Global_Data_Became_Non_Const
    # Typedef
    $HEADER1 .= "
        typedef const int CONST_INT;
        $EXTERN $DECL_SPEC CONST_INT globalDataBecameNonConst_Typedef = 10;";

    $HEADER2 .= "
        extern $DECL_SPEC int globalDataBecameNonConst_Typedef;";
    $SOURCE2 .= "
        int globalDataBecameNonConst_Typedef = 15;";

    # Global_Data_Became_Const
    $HEADER1 .= "
        extern $DECL_SPEC int globalDataBecameConst;";
    $SOURCE1 .= "
        int globalDataBecameConst = 10;";

    $HEADER2 .= "
        $EXTERN $DECL_SPEC const int globalDataBecameConst = 15;";

    # Global_Data_Became_Non_Const
    $HEADER1 .= "
        struct GlobalDataType{int a;int b;struct GlobalDataType* p;};
        $EXTERN $DECL_SPEC const struct GlobalDataType globalStructDataBecameNonConst = { 1, 2, (struct GlobalDataType*)0 };";

    $HEADER2 .= "
        struct GlobalDataType{int a;int b;struct GlobalDataType* p;};
        $EXTERN $DECL_SPEC struct GlobalDataType globalStructDataBecameNonConst = { 1, 2, (struct GlobalDataType*)0 };";

    # Removed_Parameter
    $HEADER1 .= "
        $DECL_SPEC int removedParameter(int param, int removed_param);";
    $SOURCE1 .= "
        int removedParameter(int param, int removed_param) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC int removedParameter(int param);";
    $SOURCE2 .= "
        int removedParameter(int param) { return 0; }";

    # Added_Parameter
    $HEADER1 .= "
        $DECL_SPEC int addedParameter(int param);";
    $SOURCE1 .= "
        int addedParameter(int param) { return param; }";

    $HEADER2 .= "
        $DECL_SPEC int addedParameter(int param, int added_param, int added_param2);";
    $SOURCE2 .= "
        int addedParameter(int param, int added_param, int added_param2) { return added_param2; }";

    # Added_Interface (typedef to funcptr parameter)
    $HEADER2 .= "
        typedef int (*FUNCPTR_TYPE)(int a, int b);
        $DECL_SPEC int addedFunc(FUNCPTR_TYPE*const** f);";
    $SOURCE2 .= "
        int addedFunc(FUNCPTR_TYPE*const** f) { return 0; }";

    # Added_Interface (funcptr parameter)
    $HEADER2 .= "
        $DECL_SPEC int addedFunc2(int(*func)(int, int));";
    $SOURCE2 .= "
        int addedFunc2(int(*func)(int, int)) { return 0; }";

    # Added_Interface (no limited parameters)
    $HEADER2 .= "
        $DECL_SPEC int addedFunc3(float p1, ...);";
    $SOURCE2 .= "
        int addedFunc3(float p1, ...) { return 0; }";

    # Size
    $HEADER1 .= "
        struct TypeSize
        {
            long long i[5];
            long j;
            double k;
            struct TypeSize* p;
        };
        $DECL_SPEC int testSize(struct TypeSize param, int param_2);";
    $SOURCE1 .= "
        int testSize(struct TypeSize param, int param_2) { return param_2; }";

    $HEADER2 .= "
        struct TypeSize
        {
            long long i[15];
            long long j;
            double k;
            struct TypeSize* p;
        };
        $DECL_SPEC int testSize(struct TypeSize param, int param_2);";
    $SOURCE2 .= "
        int testSize(struct TypeSize param, int param_2) { return param_2; }";

    # Added_Field_And_Size
    $HEADER1 .= "
        struct AddedFieldAndSize
        {
            int i;
            long j;
            double k;
            struct AddedFieldAndSize* p;
        };
        $DECL_SPEC int addedFieldAndSize(struct AddedFieldAndSize param, int param_2);";
    $SOURCE1 .= "
        int addedFieldAndSize(struct AddedFieldAndSize param, int param_2) { return param_2; }";

    $HEADER2 .= "
        struct AddedFieldAndSize
        {
            int i;
            long j;
            double k;
            struct AddedFieldAndSize* p;
            int added_member1;
            int added_member2;
        };
        $DECL_SPEC int addedFieldAndSize(struct AddedFieldAndSize param, int param_2);";
    $SOURCE2 .= "
        int addedFieldAndSize(struct AddedFieldAndSize param, int param_2) { return param_2; }";

    # Added_Middle_Field_And_Size
    $HEADER1 .= "
        struct AddedMiddleFieldAndSize
        {
            int i;
            long j;
            double k;
            struct AddedMiddleFieldAndSize* p;
        };
        $DECL_SPEC int addedMiddleFieldAndSize(struct AddedMiddleFieldAndSize param, int param_2);";
    $SOURCE1 .= "
        int addedMiddleFieldAndSize(struct AddedMiddleFieldAndSize param, int param_2) { return param_2; }";

    $HEADER2 .= "
        struct AddedMiddleFieldAndSize
        {
            int i;
            int added_middle_member;
            long j;
            double k;
            struct AddedMiddleFieldAndSize* p;
        };
        $DECL_SPEC int addedMiddleFieldAndSize(struct AddedMiddleFieldAndSize param, int param_2);";
    $SOURCE2 .= "
        int addedMiddleFieldAndSize(struct AddedMiddleFieldAndSize param, int param_2) { return param_2; }";

    # Added_Middle_Field
    $HEADER1 .= "
        struct AddedMiddleField
        {
            unsigned char field1;
            unsigned short field2;
        };
        $DECL_SPEC int addedMiddleField(struct AddedMiddleField param, int param_2);";
    $SOURCE1 .= "
        int addedMiddleField(struct AddedMiddleField param, int param_2) { return param_2; }";

    $HEADER2 .= "
        struct AddedMiddleField
        {
            unsigned char field1;
            unsigned char added_field;
            unsigned short field2;
        };
        $DECL_SPEC int addedMiddleField(struct AddedMiddleField param, int param_2);";
    $SOURCE2 .= "
        int addedMiddleField(struct AddedMiddleField param, int param_2) { return param_2; }";

    # Renamed_Field
    $HEADER1 .= "
        struct RenamedField
        {
            long i;
            long j;
            double k;
            struct RenamedField* p;
        };
        $DECL_SPEC int renamedField(struct RenamedField param, int param_2);";
    $SOURCE1 .= "
        int renamedField(struct RenamedField param, int param_2) { return param_2; }";

    $HEADER2 .= "
        struct RenamedField
        {
            long renamed_member;
            long j;
            double k;
            struct RenamedField* p;
        };
        $DECL_SPEC int renamedField(struct RenamedField param, int param_2);";
    $SOURCE2 .= "
        int renamedField(struct RenamedField param, int param_2) { return param_2; }";

    # Renamed_Field
    $HEADER1 .= "
        union RenamedUnionField
        {
            int renamed_from;
            double j;
        };
        $DECL_SPEC int renamedUnionField(union RenamedUnionField param);";
    $SOURCE1 .= "
        int renamedUnionField(union RenamedUnionField param) { return 0; }";

    $HEADER2 .= "
        union RenamedUnionField
        {
            int renamed_to;
            double j;
        };
        $DECL_SPEC int renamedUnionField(union RenamedUnionField param);";
    $SOURCE2 .= "
        int renamedUnionField(union RenamedUnionField param) { return 0; }";

    # Removed_Field_And_Size
    $HEADER1 .= "
        struct RemovedFieldAndSize
        {
            int i;
            long j;
            double k;
            struct RemovedFieldAndSize* p;
            int removed_member1;
            int removed_member2;
        };
        $DECL_SPEC int removedFieldAndSize(struct RemovedFieldAndSize param, int param_2);";
    $SOURCE1 .= "
        int removedFieldAndSize(struct RemovedFieldAndSize param, int param_2) { return param_2; }";

    $HEADER2 .= "
        struct RemovedFieldAndSize
        {
            int i;
            long j;
            double k;
            struct RemovedFieldAndSize* p;
        };
        $DECL_SPEC int removedFieldAndSize(struct RemovedFieldAndSize param, int param_2);";
    $SOURCE2 .= "
        int removedFieldAndSize(struct RemovedFieldAndSize param, int param_2) { return param_2; }";

    # Removed_Middle_Field
    $HEADER1 .= "
        struct RemovedMiddleField
        {
            int i;
            int removed_middle_member;
            long j;
            double k;
            struct RemovedMiddleField* p;
        };
        $DECL_SPEC int removedMiddleField(struct RemovedMiddleField param, int param_2);";
    $SOURCE1 .= "
        int removedMiddleField(struct RemovedMiddleField param, int param_2) { return param_2; }";

    $HEADER2 .= "
        struct RemovedMiddleField
        {
            int i;
            long j;
            double k;
            struct RemovedMiddleField* p;
        };
        $DECL_SPEC int removedMiddleField(struct RemovedMiddleField param, int param_2);";
    $SOURCE2 .= "
        int removedMiddleField(struct RemovedMiddleField param, int param_2) { return param_2; }";

    # Enum_Member_Value
    $HEADER1 .= "
        enum EnumMemberValue
        {
            MEMBER1=1,
            MEMBER2=2
        };
        $DECL_SPEC int enumMemberValue(enum EnumMemberValue param);";
    $SOURCE1 .= "
        int enumMemberValue(enum EnumMemberValue param) { return 0; }";

    $HEADER2 .= "
        enum EnumMemberValue
        {
            MEMBER1=2,
            MEMBER2=1
        };
        $DECL_SPEC int enumMemberValue(enum EnumMemberValue param);";
    $SOURCE2 .= "
        int enumMemberValue(enum EnumMemberValue param) { return 0; }";

    # Enum_Member_Removed
    $HEADER1 .= "
        enum EnumMemberRemoved
        {
            MEMBER=1,
            MEMBER_REMOVED=2
        };
        $DECL_SPEC int enumMemberRemoved(enum EnumMemberRemoved param);";
    $SOURCE1 .= "
        int enumMemberRemoved(enum EnumMemberRemoved param) { return 0; }";

    $HEADER2 .= "
        enum EnumMemberRemoved
        {
            MEMBER=1
        };
        $DECL_SPEC int enumMemberRemoved(enum EnumMemberRemoved param);";
    $SOURCE2 .= "
        int enumMemberRemoved(enum EnumMemberRemoved param) { return 0; }";

    # Enum_Member_Removed (middle)
    $HEADER1 .= "
        enum EnumMiddleMemberRemoved
        {
            MEM_REMOVED,
            MEM1,
            MEM2
        };
        $DECL_SPEC int enumMiddleMemberRemoved(enum EnumMiddleMemberRemoved param);";
    $SOURCE1 .= "
        int enumMiddleMemberRemoved(enum EnumMiddleMemberRemoved param) { return 0; }";

    $HEADER2 .= "
        enum EnumMiddleMemberRemoved
        {
            MEM1,
            MEM2
        };
        $DECL_SPEC int enumMiddleMemberRemoved(enum EnumMiddleMemberRemoved param);";
    $SOURCE2 .= "
        int enumMiddleMemberRemoved(enum EnumMiddleMemberRemoved param) { return 0; }";

    # Enum_Member_Name
    $HEADER1 .= "
        enum EnumMemberName
        {
            BRANCH1=1,
            BRANCH2=2
        };
        $DECL_SPEC int enumMemberName(enum EnumMemberName param);";
    $SOURCE1 .= "
        int enumMemberName(enum EnumMemberName param) { return 0; }";

    $HEADER2 .= "
        enum EnumMemberName
        {
            BRANCH_FIRST=1,
            BRANCH_SECOND=2
        };
        $DECL_SPEC int enumMemberName(enum EnumMemberName param);";
    $SOURCE2 .= "
        int enumMemberName(enum EnumMemberName param) { return 0; }";

    # Field_Type_And_Size
    $HEADER1 .= "
        struct FieldTypeAndSize
        {
            int i;
            long j;
            double k;
            struct FieldTypeAndSize* p;
        };
        $DECL_SPEC int fieldTypeAndSize(struct FieldTypeAndSize param, int param_2);";
    $SOURCE1 .= "
        int fieldTypeAndSize(struct FieldTypeAndSize param, int param_2) { return param_2; }";

    $HEADER2 .= "
        struct FieldTypeAndSize
        {
            int i;
            long long j;
            double k;
            struct FieldTypeAndSize* p;
        };
        $DECL_SPEC int fieldTypeAndSize(struct FieldTypeAndSize param, int param_2);";
    $SOURCE2 .= "
        int fieldTypeAndSize(struct FieldTypeAndSize param, int param_2) { return param_2; }";

    # Field_Type
    $HEADER1 .= "
        struct FieldType
        {
            int i;
            long j;
            double k;
            struct FieldType* p;
        };
        $DECL_SPEC int fieldType(struct FieldType param, int param_2);";
    $SOURCE1 .= "
        int fieldType(struct FieldType param, int param_2) { return param_2; }";

    $HEADER2 .= "
        struct FieldType
        {
            float i;
            long j;
            double k;
            struct FieldType* p;
        };
        $DECL_SPEC int fieldType(struct FieldType param, int param_2);";
    $SOURCE2 .= "
        int fieldType(struct FieldType param, int param_2) { return param_2; }";

    # Field_BaseType
    $HEADER1 .= "
        struct FieldBaseType
        {
            int i;
            long *j;
            double k;
            struct FieldBaseType* p;
        };
        $DECL_SPEC int fieldBaseType(struct FieldBaseType param, int param_2);";
    $SOURCE1 .= "
        int fieldBaseType(struct FieldBaseType param, int param_2) { return param_2; }";

    $HEADER2 .= "
        struct FieldBaseType
        {
            int i;
            long long *j;
            double k;
            struct FieldBaseType* p;
        };
        $DECL_SPEC int fieldBaseType(struct FieldBaseType param, int param_2);";
    $SOURCE2 .= "
        int fieldBaseType(struct FieldBaseType param, int param_2) { return param_2; }";

    # Field_PointerLevel (and Size)
    $HEADER1 .= "
        struct FieldPointerLevelAndSize
        {
            int i;
            long long j;
            double k;
            struct FieldPointerLevelAndSize* p;
        };
        $DECL_SPEC int fieldPointerLevelAndSize(struct FieldPointerLevelAndSize param, int param_2);";
    $SOURCE1 .= "
        int fieldPointerLevelAndSize(struct FieldPointerLevelAndSize param, int param_2) { return param_2; }";

    $HEADER2 .= "
        struct FieldPointerLevelAndSize
        {
            int i;
            long long *j;
            double k;
            struct FieldPointerLevelAndSize* p;
        };
        $DECL_SPEC int fieldPointerLevelAndSize(struct FieldPointerLevelAndSize param, int param_2);";
    $SOURCE2 .= "
        int fieldPointerLevelAndSize(struct FieldPointerLevelAndSize param, int param_2) { return param_2; }";

    # Field_PointerLevel
    $HEADER1 .= "
        struct FieldPointerLevel
        {
            int i;
            long *j;
            double k;
            struct FieldPointerLevel* p;
        };
        $DECL_SPEC int fieldPointerLevel(struct FieldPointerLevel param, int param_2);";
    $SOURCE1 .= "
        int fieldPointerLevel(struct FieldPointerLevel param, int param_2) { return param_2; }";

    $HEADER2 .= "
        struct FieldPointerLevel
        {
            int i;
            long **j;
            double k;
            struct FieldPointerLevel* p;
        };
        $DECL_SPEC int fieldPointerLevel(struct FieldPointerLevel param, int param_2);";
    $SOURCE2 .= "
        int fieldPointerLevel(struct FieldPointerLevel param, int param_2) { return param_2; }";

    # Added_Interface
    $HEADER2 .= "
        $DECL_SPEC int addedFunc4(int param);";
    $SOURCE2 .= "
        int addedFunc4(int param) { return param; }";

    # Removed_Interface
    $HEADER1 .= "
        $DECL_SPEC int removedFunc(int param);";
    $SOURCE1 .= "
        int removedFunc(int param) { return param; }";

    # Parameter_Type_And_Size
    $HEADER1 .= "
        $DECL_SPEC int parameterTypeAndSize(int param, int other_param);";
    $SOURCE1 .= "
        int parameterTypeAndSize(int param, int other_param) { return other_param; }";

    $HEADER2 .= "
        $DECL_SPEC int parameterTypeAndSize(long long param, int other_param);";
    $SOURCE2 .= "
        int parameterTypeAndSize(long long param, int other_param) { return other_param; }";

    # Parameter_Type_And_Size + Parameter_Became_Non_Const
    $HEADER1 .= "
        $DECL_SPEC int parameterTypeAndSizeBecameNonConst(int* const param, int other_param);";
    $SOURCE1 .= "
        int parameterTypeAndSizeBecameNonConst(int* const param, int other_param) { return other_param; }";

    $HEADER2 .= "
        $DECL_SPEC int parameterTypeAndSizeBecameNonConst(long double param, int other_param);";
    $SOURCE2 .= "
        int parameterTypeAndSizeBecameNonConst(long double param, int other_param) { return other_param; }";

    # Parameter_Type_And_Size (test calling conventions)
    $HEADER1 .= "
        $DECL_SPEC int parameterCallingConvention(int p1, int p2, int p3);";
    $SOURCE1 .= "
        int parameterCallingConvention(int p1, int p2, int p3) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC float parameterCallingConvention(char p1, int p2, int p3);";
    $SOURCE2 .= "
        float parameterCallingConvention(char p1, int p2, int p3) { return 7.0f; }";

    # Parameter_Type
    $HEADER1 .= "
        $DECL_SPEC int parameterType(int param, int other_param);";
    $SOURCE1 .= "
        int parameterType(int param, int other_param) { return other_param; }";

    $HEADER2 .= "
        $DECL_SPEC int parameterType(float param, int other_param);";
    $SOURCE2 .= "
        int parameterType(float param, int other_param) { return other_param; }";

    # Parameter_Became_Non_Const
    $HEADER1 .= "
        $DECL_SPEC int parameterBecameNonConst(int const* param);";
    $SOURCE1 .= "
        int parameterBecameNonConst(int const* param) { return *param; }";

    $HEADER2 .= "
        $DECL_SPEC int parameterBecameNonConst(int* param);";
    $SOURCE2 .= "
        int parameterBecameNonConst(int* param) {
            *param=10;
            return *param;
        }";

    # Parameter_Became_Non_Const + Parameter_Became_Non_Volatile
    $HEADER1 .= "
        $DECL_SPEC int parameterBecameNonConstNonVolatile(int const volatile* param);";
    $SOURCE1 .= "
        int parameterBecameNonConstNonVolatile(int const volatile* param) { return *param; }";

    $HEADER2 .= "
        $DECL_SPEC int parameterBecameNonConstNonVolatile(int* param);";
    $SOURCE2 .= "
        int parameterBecameNonConstNonVolatile(int* param) {
            *param=10;
            return *param;
        }";

    # Parameter_BaseType (Typedef)
    $HEADER1 .= "
        typedef int* PARAM_TYPEDEF;
        $DECL_SPEC int parameterBaseTypedefChange(PARAM_TYPEDEF param);";
    $SOURCE1 .= "
        int parameterBaseTypedefChange(PARAM_TYPEDEF param) { return 0; }";

    $HEADER2 .= "
        typedef const int* PARAM_TYPEDEF;
        $DECL_SPEC int parameterBaseTypedefChange(PARAM_TYPEDEF param);";
    $SOURCE2 .= "
        int parameterBaseTypedefChange(PARAM_TYPEDEF param) { return 0; }";

    # Parameter_BaseType
    $HEADER1 .= "
        $DECL_SPEC int parameterBaseTypeChange(int *param);";
    $SOURCE1 .= "
        int parameterBaseTypeChange(int *param) { return sizeof(*param); }";

    $HEADER2 .= "
        $DECL_SPEC int parameterBaseTypeChange(long long *param);";
    $SOURCE2 .= "
        int parameterBaseTypeChange(long long *param) { return sizeof(*param); }";

    # Parameter_PointerLevel
    $HEADER1 .= "
        $DECL_SPEC long long parameterPointerLevelAndSize(long long param);";
    $SOURCE1 .= "
        long long parameterPointerLevelAndSize(long long param) { return param; }";

    $HEADER2 .= "
        $DECL_SPEC long long parameterPointerLevelAndSize(long long *param);";
    $SOURCE2 .= "
        long long parameterPointerLevelAndSize(long long *param) { return param[5]; }";

    # Parameter_PointerLevel
    $HEADER1 .= "
        $DECL_SPEC int parameterPointerLevel(int *param);";
    $SOURCE1 .= "
        int parameterPointerLevel(int *param) { return param[5]; }";

    $HEADER2 .= "
        $DECL_SPEC int parameterPointerLevel(int **param);";
    $SOURCE2 .= "
        int parameterPointerLevel(int **param) { return param[5][5]; }";

    # Return_Type_And_Size
    $HEADER1 .= "
        $DECL_SPEC int returnTypeAndSize(int param);";
    $SOURCE1 .= "
        int returnTypeAndSize(int param) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC long long returnTypeAndSize(int param);";
    $SOURCE2 .= "
        long long returnTypeAndSize(int param) { return 0; }";

    # Return_Type
    $HEADER1 .= "
        $DECL_SPEC int returnType(int param);";
    $SOURCE1 .= "
        int returnType(int param) { return 1; }";

    $HEADER2 .= "
        $DECL_SPEC float returnType(int param);";
    $SOURCE2 .= "
        float returnType(int param) { return 1; }";

    # Return_Type_Became_Void ("int" to "void")
    $HEADER1 .= "
        $DECL_SPEC int returnTypeChangeToVoid(int param);";
    $SOURCE1 .= "
        int returnTypeChangeToVoid(int param) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC void returnTypeChangeToVoid(int param);";
    $SOURCE2 .= "
        void returnTypeChangeToVoid(int param) { return; }";

    # Return_Type ("struct" to "void*")
    $HEADER1 .= "
        struct SomeStruct {
            int a;
            double b, c, d;
        };
        $DECL_SPEC struct SomeStruct* returnTypeChangeToVoidPtr(int param);";
    $SOURCE1 .= "
        struct SomeStruct* returnTypeChangeToVoidPtr(int param) { return (struct SomeStruct*)0; }";

    $HEADER2 .= "
        struct SomeStruct {
            int a;
            double b, c, d;
        };
        $DECL_SPEC void* returnTypeChangeToVoidPtr(int param);";
    $SOURCE2 .= "
        void* returnTypeChangeToVoidPtr(int param) { return (void*)0; }";

    # Return_Type (structure change)
    $HEADER1 .= "
        struct SomeStruct2 {
            int a;
            int b;
        };
        $DECL_SPEC struct SomeStruct2 returnType2(int param);";
    $SOURCE1 .= "
        struct SomeStruct2 returnType2(int param) { struct SomeStruct2 r = {1, 2};return r; }";

    $HEADER2 .= "
        struct SomeStruct2 {
            int a;
        };
        $DECL_SPEC struct SomeStruct2 returnType2(int param);";
    $SOURCE2 .= "
        struct SomeStruct2 returnType2(int param) { struct SomeStruct2 r = {1};return r; }";

    # Return_Type (structure change)
    $HEADER1 .= "
        struct SomeStruct3 {
            int a;
            int b;
        };
        $DECL_SPEC struct SomeStruct3 returnType3(int param);";
    $SOURCE1 .= "
        struct SomeStruct3 returnType3(int param) { struct SomeStruct3 r = {1, 2};return r; }";

    $HEADER2 .= "
        struct SomeStruct3 {
            int a;
            long double b;
        };
        $DECL_SPEC struct SomeStruct3 returnType3(int param);";
    $SOURCE2 .= "
        struct SomeStruct3 returnType3(int param) { struct SomeStruct3 r = {1, 2.0L};return r; }";

    # Return_Type_From_Void_And_Stack_Layout ("void" to "struct")
    $HEADER1 .= "
        $DECL_SPEC void returnTypeChangeFromVoidToStruct(int param);";
    $SOURCE1 .= "
        void returnTypeChangeFromVoidToStruct(int param) { return; }";

    $HEADER2 .= "
        $DECL_SPEC struct SomeStruct returnTypeChangeFromVoidToStruct(int param);";
    $SOURCE2 .= "
        struct SomeStruct returnTypeChangeFromVoidToStruct(int param) {
            struct SomeStruct obj = {1,2};
            return obj;
        }";

    # Return_Type_Became_Void_And_Stack_Layout ("struct" to "void")
    $HEADER1 .= "
        $DECL_SPEC struct SomeStruct returnTypeChangeFromStructToVoid(int param);";
    $SOURCE1 .= "
        struct SomeStruct returnTypeChangeFromStructToVoid(int param) {
            struct SomeStruct obj = {1,2};
            return obj;
        }";

    $HEADER2 .= "
        $DECL_SPEC void returnTypeChangeFromStructToVoid(int param);";
    $SOURCE2 .= "
        void returnTypeChangeFromStructToVoid(int param) { return; }";

    # Return_Type_From_Void_And_Stack_Layout (safe, "void" to "long")
    $HEADER1 .= "
        $DECL_SPEC void returnTypeChangeFromVoidToLong(int param);";
    $SOURCE1 .= "
        void returnTypeChangeFromVoidToLong(int param) { return; }";

    $HEADER2 .= "
        $DECL_SPEC long returnTypeChangeFromVoidToLong(int param);";
    $SOURCE2 .= "
        long returnTypeChangeFromVoidToLong(int param) { return 0; }";

    # Return_Type_From_Void_And_Stack_Layout (safe, "void" to "void*")
    $HEADER1 .= "
        $DECL_SPEC void returnTypeChangeFromVoidToVoidPtr(int param);";
    $SOURCE1 .= "
        void returnTypeChangeFromVoidToVoidPtr(int param) { return; }";

    $HEADER2 .= "
        $DECL_SPEC void* returnTypeChangeFromVoidToVoidPtr(int param);";
    $SOURCE2 .= "
        void* returnTypeChangeFromVoidToVoidPtr(int param) { return 0; }";

    # Return_Type_From_Register_To_Stack ("int" to "struct")
    $HEADER1 .= "
        $DECL_SPEC int returnTypeChangeFromIntToStruct(int param);";
    $SOURCE1 .= "
        int returnTypeChangeFromIntToStruct(int param) { return param; }";

    $HEADER2 .= "
        $DECL_SPEC struct SomeStruct returnTypeChangeFromIntToStruct(int param);";
    $SOURCE2 .= "
        struct SomeStruct returnTypeChangeFromIntToStruct(int param) {
            struct SomeStruct obj = {1,2};
            return obj;
        }";

    # Return_Type_From_Stack_To_Register (from struct to int)
    $HEADER1 .= "
        $DECL_SPEC struct SomeStruct returnTypeChangeFromStructToInt(int param);";
    $SOURCE1 .= "
        struct SomeStruct returnTypeChangeFromStructToInt(int param) {
            struct SomeStruct obj = {1,2};
            return obj;
        }";

    $HEADER2 .= "
        $DECL_SPEC int returnTypeChangeFromStructToInt(int param);";
    $SOURCE2 .= "
        int returnTypeChangeFromStructToInt(int param) { return param; }";

     # Return_Type_From_Stack_To_Register (from struct to int, without parameters)
    $HEADER1 .= "
        $DECL_SPEC struct SomeStruct returnTypeChangeFromStructToIntWithNoParams();";
    $SOURCE1 .= "
        struct SomeStruct returnTypeChangeFromStructToIntWithNoParams() {
            struct SomeStruct obj = {1,2};
            return obj;
        }";

    $HEADER2 .= "
        $DECL_SPEC int returnTypeChangeFromStructToIntWithNoParams();";
    $SOURCE2 .= "
        int returnTypeChangeFromStructToIntWithNoParams() { return 0; }";

    # Return_BaseType
    $HEADER1 .= "
        $DECL_SPEC int *returnBaseTypeChange(int param);";
    $SOURCE1 .= "
        int *returnBaseTypeChange(int param) { return (int*)0; }";

    $HEADER2 .= "
        $DECL_SPEC long long *returnBaseTypeChange(int param);";
    $SOURCE2 .= "
        long long *returnBaseTypeChange(int param) { return (long long*)0; }";

    # Return_PointerLevel
    $HEADER1 .= "
        $DECL_SPEC long long returnPointerLevelAndSize(int param);";
    $SOURCE1 .= "
        long long returnPointerLevelAndSize(int param) { return 100; }";

    $HEADER2 .= "
        $DECL_SPEC long long *returnPointerLevelAndSize(int param);";
    $SOURCE2 .= "
        long long *returnPointerLevelAndSize(int param) { return (long long *)0; }";

    # Return_PointerLevel
    $HEADER1 .= "
        $DECL_SPEC long long *returnPointerLevel(int param);";
    $SOURCE1 .= "
        long long *returnPointerLevel(int param) { return (long long *)0; }";

    $HEADER2 .= "
        $DECL_SPEC long long **returnPointerLevel(int param);";
    $SOURCE2 .= "
        long long **returnPointerLevel(int param) { return (long long **)0; }";

    # Size (typedef to anon structure)
    $HEADER1 .= "
        typedef struct
        {
            int i;
            long j;
            double k;
        } AnonTypedef;
        $DECL_SPEC int anonTypedef(AnonTypedef param);";
    $SOURCE1 .= "
        int anonTypedef(AnonTypedef param) { return 0; }";

    $HEADER2 .= "
        typedef struct
        {
            int i;
            long j;
            double k;
            union {
                int dummy[256];
                struct {
                    char q_skiptable[256];
                    const char *p;
                    int l;
                } p;
            };
        } AnonTypedef;
        $DECL_SPEC int anonTypedef(AnonTypedef param);";
    $SOURCE2 .= "
        int anonTypedef(AnonTypedef param) { return 0; }";

    # Size (safe: opaque)
    $HEADER1 .= "
        struct OpaqueType
        {
            long long i[5];
            long j;
            double k;
            struct OpaqueType* p;
        };
        $DECL_SPEC int opaqueTypeUse(struct OpaqueType param, int param_2);";
    $SOURCE1 .= "
        int opaqueTypeUse(struct OpaqueType param, int param_2) { return param_2; }";

    $HEADER2 .= "
        struct OpaqueType
        {
            long long i[5];
            long long j;
            double k;
            struct OpaqueType* p;
        };
        $DECL_SPEC int opaqueTypeUse(struct OpaqueType param, int param_2);";
    $SOURCE2 .= "
        int opaqueTypeUse(struct OpaqueType param, int param_2) { return param_2; }";

    # Size (safe: internal)
    $HEADER1 .= "
        struct InternalType
        {
            long long i[5];
            long j;
            double k;
            struct InternalType* p;
        };
        $DECL_SPEC int internalTypeUse(struct InternalType param, int param_2);";
    $SOURCE1 .= "
        int internalTypeUse(struct InternalType param, int param_2) { return param_2; }";

    $HEADER2 .= "
        struct InternalType
        {
            long long i[5];
            long long j;
            double k;
            struct InternalType* p;
        };
        $DECL_SPEC int internalTypeUse(struct InternalType param, int param_2);";
    $SOURCE2 .= "
        int internalTypeUse(struct InternalType param, int param_2) { return param_2; }";

    if($OSgroup eq "linux")
    {
        # Changed version
        $HEADER1 .= "
            $DECL_SPEC int changedVersion(int param);
            $DECL_SPEC int changedDefaultVersion(int param);";
        $SOURCE1 .= "
            int changedVersion(int param) { return 0; }
            __asm__(\".symver changedVersion,changedVersion\@VERSION_2.0\");
            int changedDefaultVersion(int param) { return 0; }";

        $HEADER2 .= "
            $DECL_SPEC int changedVersion(int param);
            $DECL_SPEC int changedDefaultVersion(long param);";
        $SOURCE2 .= "
            int changedVersion(int param) { return 0; }
            __asm__(\".symver changedVersion,changedVersion\@VERSION_3.0\");
            int changedDefaultVersion(long param) { return 0; }";

        # Unchanged version
        $HEADER1 .= "
            $DECL_SPEC int unchangedVersion(int param);
            $DECL_SPEC int unchangedDefaultVersion(int param);";
        $SOURCE1 .= "
            int unchangedVersion(int param) { return 0; }
            __asm__(\".symver unchangedVersion,unchangedVersion\@VERSION_1.0\");
            int unchangedDefaultVersion(int param) { return 0; }";

        $HEADER2 .= "
            $DECL_SPEC int unchangedVersion(int param);
            $DECL_SPEC int unchangedDefaultVersion(int param);";
        $SOURCE2 .= "
            int unchangedVersion(int param) { return 0; }
            __asm__(\".symver unchangedVersion,unchangedVersion\@VERSION_1.0\");
            int unchangedDefaultVersion(int param) { return 0; }";

        # Non-Default to Default
        $HEADER1 .= "
            $DECL_SPEC int changedVersionToDefault(int param);";
        $SOURCE1 .= "
            int changedVersionToDefault(int param) { return 0; }
            __asm__(\".symver changedVersionToDefault,changedVersionToDefault\@VERSION_1.0\");";

        $HEADER2 .= "
            $DECL_SPEC int changedVersionToDefault(long param);";
        $SOURCE2 .= "
            int changedVersionToDefault(long param) { return 0; }";

        # Default to Non-Default
        $HEADER1 .= "
            $DECL_SPEC int changedVersionToNonDefault(int param);";
        $SOURCE1 .= "
            int changedVersionToNonDefault(int param) { return 0; }";

        $HEADER2 .= "
            $DECL_SPEC int changedVersionToNonDefault(long param);";
        $SOURCE2 .= "
            int changedVersionToNonDefault(long param) { return 0; }
            __asm__(\".symver changedVersionToNonDefault,changedVersionToNonDefault\@VERSION_3.0\");";

        # Added version
        $HEADER1 .= "
            $DECL_SPEC int addedVersion(int param);
            $DECL_SPEC int addedDefaultVersion(int param);";
        $SOURCE1 .= "
            int addedVersion(int param) { return 0; }
            int addedDefaultVersion(int param) { return 0; }";

        $HEADER2 .= "
            $DECL_SPEC int addedVersion(int param);
            $DECL_SPEC int addedDefaultVersion(int param);";
        $SOURCE2 .= "
            int addedVersion(int param) { return 0; }
            __asm__(\".symver addedVersion,addedVersion\@VERSION_2.0\");
            int addedDefaultVersion(int param) { return 0; }";

        # Removed version
        $HEADER1 .= "
            $DECL_SPEC int removedVersion(int param);
            $DECL_SPEC int removedVersion2(int param);
            $DECL_SPEC int removedDefaultVersion(int param);";
        $SOURCE1 .= "
            int removedVersion(int param) { return 0; }
            __asm__(\".symver removedVersion,removedVersion\@VERSION_1.0\");
            int removedVersion2(int param) { return 0; }
            __asm__(\".symver removedVersion2,removedVersion\@VERSION_3.0\");
            int removedDefaultVersion(int param) { return 0; }";

        $HEADER2 .= "
            $DECL_SPEC int removedVersion(int param);
            $DECL_SPEC int removedVersion2(int param);
            $DECL_SPEC int removedDefaultVersion(int param);";
        $SOURCE2 .= "
            int removedVersion(int param) { return 0; }
            int removedVersion2(int param) { return 0; }
            __asm__(\".symver removedVersion2,removedVersion\@VERSION_3.0\");
            int removedDefaultVersion(int param) { return 0; }";

        # Return_Type (good versioning)
        $HEADER1 .= "
            $DECL_SPEC int goodVersioning(int param);";
        $SOURCE1 .= "
            int goodVersioning(int param) { return 0; }
            __asm__(\".symver goodVersioning,goodVersioning\@VERSION_1.0\");";

        $HEADER2 .= "
            $DECL_SPEC int goodVersioningOld(int param);";
        $SOURCE2 .= "
            int goodVersioningOld(int param) { return 0; }
            __asm__(\".symver goodVersioningOld,goodVersioning\@VERSION_1.0\");";

        $HEADER2 .= "
            $DECL_SPEC float goodVersioning(int param);";
        $SOURCE2 .= "
            float goodVersioning(int param) { return 0.7; }
            __asm__(\".symver goodVersioning,goodVersioning\@VERSION_2.0\");";

        # Return_Type (bad versioning)
        $HEADER1 .= "
            $DECL_SPEC int badVersioning(int param);";
        $SOURCE1 .= "
            int badVersioning(int param) { return 0; }
            __asm__(\".symver badVersioning,badVersioning\@VERSION_1.0\");";

        $HEADER2 .= "
            $DECL_SPEC float badVersioningOld(int param);";
        $SOURCE2 .= "
            float badVersioningOld(int param) { return 0.7; }
            __asm__(\".symver badVersioningOld,badVersioning\@VERSION_1.0\");";

        $HEADER2 .= "
            $DECL_SPEC float badVersioning(int param);";
        $SOURCE2 .= "
            float badVersioning(int param) { return 0.7; }
            __asm__(\".symver badVersioning,badVersioning\@VERSION_2.0\");";
    }
    # unnamed struct/union fields within structs/unions
    $HEADER1 .= "
        typedef struct
        {
            int a;
            union {
                int b;
                float c;
            };
            int d;
        } UnnamedTypeSize;
        $DECL_SPEC int unnamedTypeSize(UnnamedTypeSize param);";
    $SOURCE1 .= "
        int unnamedTypeSize(UnnamedTypeSize param) { return 0; }";

    $HEADER2 .= "
        typedef struct
        {
            int a;
            union {
                long double b;
                float c;
            };
            int d;
        } UnnamedTypeSize;
        $DECL_SPEC int unnamedTypeSize(UnnamedTypeSize param);";
    $SOURCE2 .= "
        int unnamedTypeSize(UnnamedTypeSize param) { return 0; }";

    # Changed_Constant (#define)
    $HEADER1 .= "
        #define PUBLIC_CONSTANT \"old_value\"";
    $HEADER2 .= "
        #define PUBLIC_CONSTANT \"new_value\"";

    # Changed_Constant (Safe)
    $HEADER1 .= "
        #define INTEGER_CONSTANT 0x01";
    $HEADER2 .= "
        #define INTEGER_CONSTANT 1";

    # Changed_Constant (Safe)
    $HEADER1 .= "
        #define PRIVATE_CONSTANT \"old_value\"
        #undef PRIVATE_CONSTANT";
    $HEADER2 .= "
        #define PRIVATE_CONSTANT \"new_value\"
        #undef PRIVATE_CONSTANT";

    # Changed_Constant (enum)
    $HEADER1 .= "
        enum {
            SOME_CONSTANT=0x1
        };";
    $HEADER2 .= "
        enum {
            SOME_CONSTANT=0x2
        };";

    # Added_Constant (#define)
    $HEADER2 .= "
        #define ADDED_CNST \"value\"";

    # Added_Constant (enum)
    $HEADER1 .= "
        enum {
            CONSTANT1
        };";
    $HEADER2 .= "
        enum {
            CONSTANT1,
            ADDED_CONSTANT
        };";

    # Removed_Constant (#define)
    $HEADER1 .= "
        #define REMOVED_CNST \"value\"";

    # Removed_Constant (enum)
    $HEADER1 .= "
        enum {
            CONSTANT2,
            REMOVED_CONSTANT
        };";
    $HEADER2 .= "
        enum {
            CONSTANT2
        };";

    # Added_Field (union)
    $HEADER1 .= "
        union UnionTypeAddedField
        {
            int a;
            struct {
                int b;
                float c;
            };
            int d;
        };
        $DECL_SPEC int unionTypeAddedField(union UnionTypeAddedField param);";
    $SOURCE1 .= "
        int unionTypeAddedField(union UnionTypeAddedField param) { return 0; }";

    $HEADER2 .= "
        union UnionTypeAddedField
        {
            int a;
            struct {
                long double x, y;
            } new_field;
            struct {
                int b;
                float c;
            };
            int d;
        };
        $DECL_SPEC int unionTypeAddedField(union UnionTypeAddedField param);";
    $SOURCE2 .= "
        int unionTypeAddedField(union UnionTypeAddedField param) { return 0; }";

    # Prameter_BaseType (typedef)
    $HEADER1 .= "
        typedef float TYPEDEF_TYPE;
        $DECL_SPEC int parameterTypedefChange(TYPEDEF_TYPE param);";
    $SOURCE1 .= "
        int parameterTypedefChange(TYPEDEF_TYPE param) { return 1.0; }";

    $HEADER2 .= "
        typedef int TYPEDEF_TYPE;
        $DECL_SPEC int parameterTypedefChange(TYPEDEF_TYPE param);";
    $SOURCE2 .= "
        int parameterTypedefChange(TYPEDEF_TYPE param) { return 1; }";

    # Field_BaseType (typedef in member type)
    $HEADER1 .= "
        typedef float TYPEDEF_TYPE_2;
        struct FieldBaseTypedefChange {
            TYPEDEF_TYPE_2 m;
        };
        $DECL_SPEC int fieldBaseTypedefChange(struct FieldBaseTypedefChange param);";
    $SOURCE1 .= "
        int fieldBaseTypedefChange(struct FieldBaseTypedefChange param) { return 1; }";

    $HEADER2 .= "
        typedef int TYPEDEF_TYPE_2;
        struct FieldBaseTypedefChange {
            TYPEDEF_TYPE_2 m;
        };
        $DECL_SPEC int fieldBaseTypedefChange(struct FieldBaseTypedefChange param);";
    $SOURCE2 .= "
        int fieldBaseTypedefChange(struct FieldBaseTypedefChange param) { return 1; }";

    # C++ keywords in C code
    $HEADER1 .= "
        $DECL_SPEC int testCppKeywords1(int class, int virtual, int (*new)(int));";
    $SOURCE1 .= "
        $DECL_SPEC int testCppKeywords1(int class, int virtual, int (*new)(int)) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC int testCppKeywords1(int class, int virtual);
        $DECL_SPEC int testCppKeywords2(int operator, int other);
        $DECL_SPEC int testCppKeywords3(int operator);
        $DECL_SPEC int operator(int class, int this);
        $DECL_SPEC int delete(int virtual, int* this);
        struct CppKeywords {
            int bool: 8;
            //int*this;
        };
        #ifdef __cplusplus
            class TestCppKeywords {
                void operator delete(void*);
                void operator ()(int);
                void operator,(int);
                void delete() {
                    delete this;
                };
            };
        #endif";
    $SOURCE2 .= "
        $DECL_SPEC int testCppKeywords1(int class, int virtual) { return 0; }";

    # Regression
    $HEADER1 .= "
        $DECL_SPEC int* testRegression(int *pointer, char const *name, ...);";
    $SOURCE1 .= "
        int* testRegression(int *pointer, char const *name, ...) { return 0; }";

    $HEADER2 .= "
        $DECL_SPEC int* testRegression(int *pointer, char const *name, ...);";
    $SOURCE2 .= "
        int* testRegression(int *pointer, char const *name, ...) { return 0; }";

    runTests("libsample_c", "C", $HEADER1, $SOURCE1, $HEADER2, $SOURCE2, "struct OpaqueType", "internalTypeUse");
}

sub runTests($$$$$$$$)
{
    my ($LibName, $Lang, $HEADER1, $SOURCE1, $HEADER2, $SOURCE2, $Opaque, $Private) = @_;

    my $SrcE = ($Lang eq "C++")?"cpp":"c";
    rmtree($LibName);

    my $ObjName = "libsample";

    # creating test suite
    my $Path_v1 = "$LibName/$ObjName.v1";
    my $Path_v2 = "$LibName/$ObjName.v2";
    mkpath($Path_v1);
    mkpath($Path_v2);
    writeFile("$Path_v1/$ObjName.h", $HEADER1."\n");
    writeFile("$Path_v1/$ObjName.$SrcE", "#include \"$ObjName.h\"\n".$SOURCE1."\n");
    writeFile("$LibName/v1.xml", "
        <version>
            1.0
        </version>

        <headers>
            ".get_abs_path($Path_v1)."
        </headers>

        <libs>
            ".get_abs_path($Path_v1)."
        </libs>

        <skip_types>
            $Opaque
        </skip_types>

        <skip_symbols>
            $Private
        </skip_symbols>

        <include_paths>
            ".get_abs_path($Path_v1)."
        </include_paths>\n");
    writeFile("$Path_v1/test.$SrcE", "
        #include \"$ObjName.h\"
        #include <stdio.h>
        ".($Lang eq "C++"?"using namespace TestNS;":"")."
        int main()
        {
            int ret = 0;
            printf(\"\%d\\n\", ret);
            return 0;
        }\n");

    writeFile("$Path_v2/$ObjName.h", $HEADER2."\n");
    writeFile("$Path_v2/$ObjName.$SrcE", "#include \"$ObjName.h\"\n".$SOURCE2."\n");
    writeFile("$LibName/v2.xml", "
        <version>
            2.0
        </version>

        <headers>
            ".get_abs_path($Path_v2)."
        </headers>

        <libs>
            ".get_abs_path($Path_v2)."
        </libs>

        <skip_types>
            $Opaque
        </skip_types>

        <skip_symbols>
            $Private
        </skip_symbols>

        <include_paths>
            ".get_abs_path($Path_v2)."
        </include_paths>\n");
    writeFile("$Path_v2/test.$SrcE", "
        #include \"$ObjName.h\"
        #include <stdio.h>
        ".($Lang eq "C++"?"using namespace TestNS;":"")."
        int main()
        {
            int ret = 0;
            printf(\"\%d\\n\", ret);
            return 0;
        }\n");

    my ($BuildCmd, $BuildCmd_Test) = ("", "");
    if($OSgroup eq "windows")
    {
        check_win32_env(); # to run MS VC++ compiler
        my $CL = get_CmdPath("cl");

        if(not $CL) {
            exitStatus("Not_Found", "can't find \"cl\" compiler");
        }
        $BuildCmd = "$CL /LD $ObjName.$SrcE >build_log.txt 2>&1";
        $BuildCmd_Test = "$CL test.$SrcE $ObjName.$LIB_EXT";
    }
    elsif($OSgroup eq "linux")
    {
        if($Lang eq "C")
        { # tests for symbol versioning
            writeFile("$Path_v1/version", "
                VERSION_1.0 {
                    unchangedDefaultVersion;
                    removedDefaultVersion;
                };
                VERSION_2.0 {
                    changedDefaultVersion;
                };
                VERSION_3.0 {
                    changedVersionToNonDefault;
                };
            ");
            writeFile("$Path_v2/version", "
                VERSION_1.0 {
                    unchangedDefaultVersion;
                    changedVersionToDefault;
                };
                VERSION_2.0 {
                    addedDefaultVersion;
                };
                VERSION_3.0 {
                    changedDefaultVersion;
                };
            ");
            $BuildCmd = $GCC_PATH." -Wl,--version-script version -shared $ObjName.$SrcE -o $ObjName.$LIB_EXT -g -Og";
            $BuildCmd_Test = $GCC_PATH." -Wl,--version-script version test.$SrcE -Wl,$ObjName.$LIB_EXT -o test";
        }
        else
        {
            $BuildCmd = $GCC_PATH." -shared -x c++ $ObjName.$SrcE -lstdc++ -o $ObjName.$LIB_EXT -g -Og";
            $BuildCmd_Test = $GCC_PATH." -x c++ test.$SrcE -lstdc++ -Wl,$ObjName.$LIB_EXT -o test";
        }
        if(getArch_GCC(1)=~/\A(arm|x86_64)\Z/i)
        { # relocation R_ARM_MOVW_ABS_NC against `a local symbol' can not be used when making a shared object; recompile with -fPIC
            $BuildCmd .= " -fPIC";
            $BuildCmd_Test .= " -fPIC";
        }
    }
    elsif($OSgroup eq "macos")
    { # using GCC -dynamiclib
        if($Lang eq "C")
        {
            $BuildCmd = $GCC_PATH." -dynamiclib $ObjName.$SrcE -o $ObjName.$LIB_EXT";
            $BuildCmd_Test = $GCC_PATH." test.$SrcE $ObjName.$LIB_EXT -o test";
        }
        else
        { # C++
            $BuildCmd = $GCC_PATH." -dynamiclib -x c++ $ObjName.$SrcE -lstdc++ -o $ObjName.$LIB_EXT";
            $BuildCmd_Test = $GCC_PATH." -x c++ test.$SrcE $ObjName.$LIB_EXT -o test";
        }
    }
    else
    { # default unix-like
      # symbian target
        if($Lang eq "C")
        {
            $BuildCmd = $GCC_PATH." -shared $ObjName.$SrcE -o $ObjName.$LIB_EXT -g -Og";
            $BuildCmd_Test = $GCC_PATH." test.$SrcE -Wl,$ObjName.$LIB_EXT -o test";
        }
        else
        { # C++
            $BuildCmd = $GCC_PATH." -shared -x c++ $ObjName.$SrcE -lstdc++ -o $ObjName.$LIB_EXT -g -Og";
            $BuildCmd_Test = $GCC_PATH." -x c++ test.$SrcE -Wl,$ObjName.$LIB_EXT -o test";
        }
    }

    if(my $Opts = getGCC_Opts(1))
    { # user-defined options
        $BuildCmd .= " ".$Opts;
        $BuildCmd_Test .= " ".$Opts;
    }

    my $MkContent = "all:\n\t$BuildCmd\ntest:\n\t$BuildCmd_Test\n";
    if($OSgroup eq "windows") {
        $MkContent .= "clean:\n\tdel test $ObjName.so\n";
    }
    else {
        $MkContent .= "clean:\n\trm test $ObjName.so\n";
    }
    writeFile("$Path_v1/Makefile", $MkContent);
    writeFile("$Path_v2/Makefile", $MkContent);
    system("cd $Path_v1 && $BuildCmd >build-log.txt 2>&1");
    if($?)
    {
        my $Msg = "can't compile $LibName v.1: \'$Path_v1/build-log.txt\'";
        if(readFile("$Path_v1/build-log.txt")=~/error trying to exec \W+cc1plus\W+/) {
            $Msg .= "\nDid you install G++?";
        }
        exitStatus("Error", $Msg);
    }
    system("cd $Path_v2 && $BuildCmd >build-log.txt 2>&1");
    if($?) {
        exitStatus("Error", "can't compile $LibName v.2: \'$Path_v2/build-log.txt\'");
    }
    # executing the tool
    my @Cmd = ("perl", $0, "-l", $LibName);

    if($TestABIDumper and $OSgroup eq "linux")
    {
        my @Cmd_d1 = ("abi-dumper", $Path_v1."/".$ObjName.".".$LIB_EXT, "-o", $LibName."/ABIv1.dump");
        @Cmd_d1 = (@Cmd_d1, "-public-headers", $Path_v1, "-lver", "1.0");
        if($Debug)
        { # debug mode
            printMsg("INFO", "executing @Cmd_d1");
        }
        system(@Cmd_d1);
        printMsg("INFO", "");

        my @Cmd_d2 = ("abi-dumper", $Path_v2."/".$ObjName.".".$LIB_EXT, "-o", $LibName."/ABIv2.dump");
        @Cmd_d2 = (@Cmd_d2, "-public-headers", $Path_v2, "-lver", "2.0");
        if($Debug)
        { # debug mode
            printMsg("INFO", "executing @Cmd_d2");
        }
        system(@Cmd_d2);
        printMsg("INFO", "");

        @Cmd = (@Cmd, "-old", $LibName."/ABIv1.dump", "-new", $LibName."/ABIv2.dump");
    }
    else
    {
        @Cmd = (@Cmd, "-old", "$LibName/v1.xml", "-new", "$LibName/v2.xml");
    }

    if($Lang eq "C") {
        @Cmd = (@Cmd, "-cxx-incompatible");
    }

    if($TestDump)
    {
        @Cmd = (@Cmd, "-use-dumps");
        if($SortDump) {
            @Cmd = (@Cmd, "-sort");
        }
    }
    if($DumpFormat and $DumpFormat ne "perl")
    { # Perl Data::Dumper is default format
        @Cmd = (@Cmd, "-dump-format", $DumpFormat);
    }
    if($GCC_PATH ne "gcc") {
        @Cmd = (@Cmd, "-cross-gcc", $GCC_PATH);
    }
    if($Quiet)
    { # quiet mode
        @Cmd = (@Cmd, "-quiet");
        @Cmd = (@Cmd, "-logging-mode", "a");
    }
    elsif($LogMode and $LogMode ne "w")
    { # "w" is default
        @Cmd = (@Cmd, "-logging-mode", $LogMode);
    }
    if($ExtendedCheck)
    { # extended mode
        @Cmd = (@Cmd, "-extended");
        if($Lang eq "C") {
            @Cmd = (@Cmd, "-lang", "C");
        }
    }
    if($ReportFormat and $ReportFormat ne "html")
    { # HTML is default format
        @Cmd = (@Cmd, "-report-format", $ReportFormat);
    }
    if($CheckHeadersOnly) {
        @Cmd = (@Cmd, "-headers-only");
    }
    if($OldStyle) {
        @Cmd = (@Cmd, "-old-style");
    }
    if($Debug)
    { # debug mode
        @Cmd = (@Cmd, "-debug");
        printMsg("INFO", "executing @Cmd");
    }
    system(@Cmd);

    my $ECode = $?>>8;

    if($ECode!~/\A[0-1]\Z/)
    { # error
        exitStatus("Error", "analysis has failed");
    }

    my $RPath = "compat_reports/$LibName/1.0_to_2.0/compat_report.$ReportFormat";
    my $NProblems = 0;
    if($ReportFormat eq "xml")
    {
        my $Content = readFile($RPath);
        # binary
        if(my $PSummary = parseTag(\$Content, "problem_summary"))
        {
            $NProblems += int(parseTag(\$PSummary, "removed_symbols"));
            if(my $TProblems = parseTag(\$PSummary, "problems_with_types"))
            {
                $NProblems += int(parseTag(\$TProblems, "high"));
                $NProblems += int(parseTag(\$TProblems, "medium"));
            }
            if(my $IProblems = parseTag(\$PSummary, "problems_with_symbols"))
            {
                $NProblems += int(parseTag(\$IProblems, "high"));
                $NProblems += int(parseTag(\$IProblems, "medium"));
            }
        }
        # source
        if(my $PSummary = parseTag(\$Content, "problem_summary"))
        {
            $NProblems += int(parseTag(\$PSummary, "removed_symbols"));
            if(my $TProblems = parseTag(\$PSummary, "problems_with_types"))
            {
                $NProblems += int(parseTag(\$TProblems, "high"));
                $NProblems += int(parseTag(\$TProblems, "medium"));
            }
            if(my $IProblems = parseTag(\$PSummary, "problems_with_symbols"))
            {
                $NProblems += int(parseTag(\$IProblems, "high"));
                $NProblems += int(parseTag(\$IProblems, "medium"));
            }
        }
    }
    else
    {
        my $BReport = readAttributes($RPath, 0);
        $NProblems += $BReport->{"removed"};
        $NProblems += $BReport->{"type_problems_high"}+$BReport->{"type_problems_medium"};
        $NProblems += $BReport->{"interface_problems_high"}+$BReport->{"interface_problems_medium"};
        my $SReport = readAttributes($RPath, 1);
        $NProblems += $SReport->{"removed"};
        $NProblems += $SReport->{"type_problems_high"}+$SReport->{"type_problems_medium"};
        $NProblems += $SReport->{"interface_problems_high"}+$SReport->{"interface_problems_medium"};
    }
    if(($LibName eq "libsample_c" and $NProblems>70)
    or ($LibName eq "libsample_cpp" and $NProblems>150)) {
        printMsg("INFO", "result: SUCCESS ($NProblems problems found)\n");
    }
    else {
        printMsg("ERROR", "result: FAILED ($NProblems problems found)\n");
    }
}

return 1;