1########################################################################### 2# A module with regression test suite 3# 4# Copyright (C) 2009-2011 Institute for System Programming, RAS 5# Copyright (C) 2011-2012 Nokia Corporation and/or its subsidiary(-ies) 6# Copyright (C) 2012-2018 Andrey Ponomarenko's ABI Laboratory 7# 8# Written by Andrey Ponomarenko 9# 10# This library is free software; you can redistribute it and/or 11# modify it under the terms of the GNU Lesser General Public 12# License as published by the Free Software Foundation; either 13# version 2.1 of the License, or (at your option) any later version. 14# 15# This library is distributed in the hope that it will be useful, 16# but WITHOUT ANY WARRANTY; without even the implied warranty of 17# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18# Lesser General Public License for more details. 19# 20# You should have received a copy of the GNU Lesser General Public 21# License along with this library; if not, write to the Free Software 22# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 23# MA 02110-1301 USA 24########################################################################### 25use strict; 26 27loadModule("ElfTools"); 28 29sub testTool() 30{ 31 if($In::Opt{"UserLang"} ne "C++") { 32 testC(); 33 } 34 35 if($In::Opt{"UserLang"} ne "C") { 36 testCpp(); 37 } 38} 39 40sub testCpp() 41{ 42 printMsg("INFO", "Verifying detectable C++ library changes"); 43 my ($HEADER1, $SOURCE1, $HEADER2, $SOURCE2) = (); 44 45 my $DECL_SPEC = ""; 46 my $EXTERN = ""; 47 48 if($In::Opt{"OS"} eq "windows") 49 { 50 $DECL_SPEC = "__declspec( dllexport )"; 51 $EXTERN = "extern "; # add "extern" for CL compiler 52 } 53 54 # Class outside namespace 55 $HEADER1 .= " 56 class $DECL_SPEC OutsideNS { 57 public: 58 int someMethod(); 59 int field; 60 };"; 61 $SOURCE1 .= " 62 int OutsideNS::someMethod() { return 0; }"; 63 64 $HEADER2 .= " 65 class $DECL_SPEC OutsideNS { 66 public: 67 int someMethod(); 68 int field; 69 int field2; 70 };"; 71 $SOURCE2 .= " 72 int OutsideNS::someMethod() { return 0; }"; 73 74 # Begin namespace 75 $HEADER1 .= "namespace TestNS {\n"; 76 $HEADER2 .= "namespace TestNS {\n"; 77 $SOURCE1 .= "namespace TestNS {\n"; 78 $SOURCE2 .= "namespace TestNS {\n"; 79 80 # Changed template internals 81 # $HEADER1 .= " 82 # template <typename T, int _P> 83 # class $DECL_SPEC ChangedTemplate { 84 # public: 85 # T value; 86 # T*const field; 87 # T array[_P]; 88 # typedef int My; 89 # My var; 90 # }; 91 # ChangedTemplate<int, 1>* changedTemplate();"; 92 # $SOURCE1 .= " 93 # ChangedTemplate<int, 1>* changedTemplate() { return new ChangedTemplate<int, 1>(); }"; 94 # 95 # $HEADER2 .= " 96 # template <typename T, int _P> 97 # class $DECL_SPEC ChangedTemplate { 98 # public: 99 # double value; 100 # T* field; 101 # double array[_P]; 102 # typedef int My; 103 # My var; 104 # }; 105 # ChangedTemplate<int, 1>* changedTemplate();"; 106 # $SOURCE2 .= " 107 # ChangedTemplate<int, 1>* changedTemplate() { return new ChangedTemplate<int, 1>(); }"; 108 109 # Removed inline method 110 $HEADER1 .= " 111 class $DECL_SPEC RemovedInlineMethod { 112 public: 113 int someMethod(); 114 inline int removedMethod() { return 0; }; 115 int field; 116 };"; 117 $SOURCE1 .= " 118 int RemovedInlineMethod::someMethod() { return removedMethod(); }"; 119 120 $HEADER2 .= " 121 class $DECL_SPEC RemovedInlineMethod { 122 public: 123 int someMethod(); 124 int field; 125 };"; 126 $SOURCE2 .= " 127 int RemovedInlineMethod::someMethod() { return 0; }"; 128 129 # Pure_Virtual_Replacement 130 $HEADER1 .= " 131 class $DECL_SPEC PureVirtualReplacement { 132 public: 133 virtual int methodOld(int param) = 0; 134 int otherMethod(); 135 }; 136 137 class $DECL_SPEC PureVirtualReplacement_Derived: public PureVirtualReplacement { 138 public: 139 int methodOld(int param); 140 };"; 141 $SOURCE1 .= " 142 int PureVirtualReplacement::otherMethod() { return 0; } 143 int PureVirtualReplacement_Derived::methodOld(int param) { return 0; }"; 144 145 $HEADER2 .= " 146 class $DECL_SPEC PureVirtualReplacement { 147 public: 148 virtual int methodNew(int param) = 0; 149 int otherMethod(); 150 }; 151 152 class $DECL_SPEC PureVirtualReplacement_Derived: public PureVirtualReplacement { 153 public: 154 int methodNew(int param); 155 };"; 156 $SOURCE2 .= " 157 int PureVirtualReplacement::otherMethod() { return 0; } 158 int PureVirtualReplacement_Derived::methodNew(int param) { return 0; }"; 159 160 # Virtual_Replacement 161 $HEADER1 .= " 162 class $DECL_SPEC VirtualReplacement { 163 public: 164 virtual int methodOld(int param); 165 };"; 166 $SOURCE1 .= " 167 int VirtualReplacement::methodOld(int param) { return 0; }"; 168 169 $HEADER2 .= " 170 class $DECL_SPEC VirtualReplacement { 171 public: 172 virtual int methodNew(int param); 173 };"; 174 $SOURCE2 .= " 175 int VirtualReplacement::methodNew(int param) { return 0; }"; 176 177 # Removed_Symbol (renamed, source-compatible) 178 $HEADER1 .= " 179 int $DECL_SPEC renamedFunc(int param);"; 180 $SOURCE1 .= " 181 int renamedFunc(int param) { return 0; }"; 182 183 $HEADER2 .= " 184 int $DECL_SPEC renamedFunc_NewName(int param); 185 #define renamedFunc renamedFunc_NewName"; 186 $SOURCE2 .= " 187 int renamedFunc_NewName(int param) { return 0; }"; 188 189 # Removed_Symbol 190 $HEADER1 .= " 191 int $DECL_SPEC functionBecameInline(int param);"; 192 $SOURCE1 .= " 193 int functionBecameInline(int param) { return 0; }"; 194 195 $HEADER2 .= " 196 inline int functionBecameInline(int param) { return 0; }"; 197 198 # Removed_Symbol (safe) 199 $HEADER1 .= " 200 inline int removedInlineFunction(int param) { return 0; }"; 201 202 # Became Non-Opaque 203 $HEADER1 .= " 204 struct OpaqueStruct; 205 int paramBecameNonOpaque(OpaqueStruct* p);"; 206 $SOURCE1 .= " 207 int paramBecameNonOpaque(OpaqueStruct* p) { return 0; }"; 208 209 $HEADER2 .= " 210 struct OpaqueStruct 211 { 212 int i; 213 short j; 214 OpaqueStruct(); 215 }; 216 int paramBecameNonOpaque(OpaqueStruct* p);"; 217 $SOURCE2 .= " 218 int paramBecameNonOpaque(OpaqueStruct* p) { return 0; }"; 219 220 # Field_Became_Const 221 # Typedef 222 $HEADER1 .= " 223 typedef int*const CONST_INT_PTR; 224 class $DECL_SPEC FieldBecameConstTypedef { 225 public: 226 int* f; 227 int*const f2; 228 int method(CONST_INT_PTR p); 229 };"; 230 $SOURCE1 .= " 231 int FieldBecameConstTypedef::method(CONST_INT_PTR p) { return 0; }"; 232 233 $HEADER2 .= " 234 typedef int*const CONST_INT_PTR; 235 class $DECL_SPEC FieldBecameConstTypedef { 236 public: 237 CONST_INT_PTR f; 238 int*const f2; 239 int method(CONST_INT_PTR p); 240 };"; 241 $SOURCE2 .= " 242 int FieldBecameConstTypedef::method(CONST_INT_PTR p) { return 0; }"; 243 244 # Field_Removed_Const 245 $HEADER1 .= " 246 class $DECL_SPEC FieldRemovedConst { 247 public: 248 int*const*const f; 249 int method(); 250 };"; 251 $SOURCE1 .= " 252 int FieldRemovedConst::method() { return 0; }"; 253 254 $HEADER2 .= " 255 class $DECL_SPEC FieldRemovedConst { 256 public: 257 int**const f; 258 int method(); 259 };"; 260 $SOURCE2 .= " 261 int FieldRemovedConst::method() { return 0; }"; 262 263 # Field_Became_Const 264 $HEADER1 .= " 265 class $DECL_SPEC FieldBecameConst { 266 public: 267 int* f; 268 int method(); 269 };"; 270 $SOURCE1 .= " 271 int FieldBecameConst::method() { return 0; }"; 272 273 $HEADER2 .= " 274 class $DECL_SPEC FieldBecameConst { 275 public: 276 int*const f; 277 int method(); 278 };"; 279 $SOURCE2 .= " 280 int FieldBecameConst::method() { return 0; }"; 281 282 # Field_Became_Private 283 $HEADER1 .= " 284 class $DECL_SPEC FieldBecamePrivate { 285 public: 286 int* f; 287 int method(); 288 };"; 289 $SOURCE1 .= " 290 int FieldBecamePrivate::method() { return 0; }"; 291 292 $HEADER2 .= " 293 class $DECL_SPEC FieldBecamePrivate { 294 private: 295 int* f; 296 public: 297 int method(); 298 };"; 299 $SOURCE2 .= " 300 int FieldBecamePrivate::method() { return 0; }"; 301 302 # Field_Became_Protected 303 $HEADER1 .= " 304 class $DECL_SPEC FieldBecameProtected { 305 public: 306 int* f; 307 int method(); 308 };"; 309 $SOURCE1 .= " 310 int FieldBecameProtected::method() { return 0; }"; 311 312 $HEADER2 .= " 313 class $DECL_SPEC FieldBecameProtected { 314 protected: 315 int* f; 316 public: 317 int method(); 318 };"; 319 $SOURCE2 .= " 320 int FieldBecameProtected::method() { return 0; }"; 321 322 # Global_Data_Became_Private 323 $HEADER1 .= " 324 class $DECL_SPEC GlobalDataBecamePrivate { 325 public: 326 static int data; 327 328 };"; 329 $SOURCE1 .= " 330 int GlobalDataBecamePrivate::data = 10;"; 331 332 $HEADER2 .= " 333 class $DECL_SPEC GlobalDataBecamePrivate { 334 private: 335 static int data; 336 337 };"; 338 $SOURCE2 .= " 339 int GlobalDataBecamePrivate::data = 10;"; 340 341 # Method_Became_Private 342 $HEADER1 .= " 343 class $DECL_SPEC MethodBecamePrivate { 344 public: 345 int method(); 346 };"; 347 $SOURCE1 .= " 348 int MethodBecamePrivate::method() { return 0; }"; 349 350 $HEADER2 .= " 351 class $DECL_SPEC MethodBecamePrivate { 352 private: 353 int method(); 354 };"; 355 $SOURCE2 .= " 356 int MethodBecamePrivate::method() { return 0; }"; 357 358 # Method_Became_Protected 359 $HEADER1 .= " 360 class $DECL_SPEC MethodBecameProtected { 361 public: 362 int method(); 363 };"; 364 $SOURCE1 .= " 365 int MethodBecameProtected::method() { return 0; }"; 366 367 $HEADER2 .= " 368 class $DECL_SPEC MethodBecameProtected { 369 protected: 370 int method(); 371 };"; 372 $SOURCE2 .= " 373 int MethodBecameProtected::method() { return 0; }"; 374 375 # Method_Became_Public 376 $HEADER1 .= " 377 class $DECL_SPEC MethodBecamePublic { 378 protected: 379 int method(); 380 };"; 381 $SOURCE1 .= " 382 int MethodBecamePublic::method() { return 0; }"; 383 384 $HEADER2 .= " 385 class $DECL_SPEC MethodBecamePublic { 386 public: 387 int method(); 388 };"; 389 $SOURCE2 .= " 390 int MethodBecamePublic::method() { return 0; }"; 391 392 # Removed_Const_Overload 393 $HEADER1 .= " 394 class $DECL_SPEC RemovedConstOverload { 395 public: 396 int removed(); 397 int removed() const; 398 };"; 399 $SOURCE1 .= " 400 int RemovedConstOverload::removed() { return 0; } 401 int RemovedConstOverload::removed() const { return 0; }"; 402 403 $HEADER2 .= " 404 class $DECL_SPEC RemovedConstOverload { 405 public: 406 int removed(); 407 };"; 408 $SOURCE2 .= " 409 int RemovedConstOverload::removed() { return 0; }"; 410 411 # Inline method 412 $HEADER1 .= " 413 class $DECL_SPEC InlineMethod { 414 public: 415 inline int foo() { return 0; } 416 };"; 417 418 $HEADER2 .= " 419 class $DECL_SPEC InlineMethod { 420 public: 421 inline long foo() { return 0; } 422 };"; 423 424 # Global_Data_Became_Non_Const 425 $HEADER1 .= " 426 $EXTERN $DECL_SPEC const int globalDataBecameNonConst = 10;"; 427 428 $HEADER2 .= " 429 extern $DECL_SPEC int globalDataBecameNonConst;"; 430 $SOURCE2 .= " 431 int globalDataBecameNonConst = 15;"; 432 433 # Global_Data_Became_Non_Const 434 # Class Member 435 $HEADER1 .= " 436 class $DECL_SPEC GlobalDataBecameNonConst { 437 public: 438 static const int data; 439 };"; 440 $SOURCE1 .= " 441 const int GlobalDataBecameNonConst::data = 10;"; 442 443 $HEADER2 .= " 444 class $DECL_SPEC GlobalDataBecameNonConst { 445 public: 446 static int data; 447 };"; 448 $SOURCE2 .= " 449 int GlobalDataBecameNonConst::data = 10;"; 450 451 # Global_Data_Became_Const 452 $HEADER1 .= " 453 extern $DECL_SPEC int globalDataBecameConst;"; 454 $SOURCE1 .= " 455 int globalDataBecameConst = 10;"; 456 457 $HEADER2 .= " 458 $EXTERN $DECL_SPEC const int globalDataBecameConst = 15;"; 459 460 # Global_Data_Became_Const 461 # Class Member 462 $HEADER1 .= " 463 class $DECL_SPEC GlobalDataBecameConst { 464 public: 465 static int Data; 466 };"; 467 $SOURCE1 .= " 468 int GlobalDataBecameConst::Data = 10;"; 469 470 $HEADER2 .= " 471 class $DECL_SPEC GlobalDataBecameConst { 472 public: 473 static const int Data = 15; 474 };"; 475 476 # Global_Data_Value_Changed 477 $HEADER1 .= " 478 class $DECL_SPEC GlobalDataValue { 479 public: 480 static const int Integer = 10; 481 static const char Char = \'o\'; 482 };"; 483 484 $HEADER2 .= " 485 class $DECL_SPEC GlobalDataValue { 486 public: 487 static const int Integer = 15; 488 static const char Char = \'N\'; 489 };"; 490 491 # Global_Data_Value_Changed 492 # Integer 493 $HEADER1 .= " 494 $EXTERN $DECL_SPEC const int globalDataValue_Integer = 10;"; 495 496 $HEADER2 .= " 497 $EXTERN $DECL_SPEC const int globalDataValue_Integer = 15;"; 498 499 # Global_Data_Value_Changed 500 # Character 501 $HEADER1 .= " 502 $EXTERN $DECL_SPEC const char globalDataValue_Char = \'o\';"; 503 504 $HEADER2 .= " 505 $EXTERN $DECL_SPEC const char globalDataValue_Char = \'N\';"; 506 507 # Parameter_Became_Restrict 508 $HEADER1 .= " 509 class $DECL_SPEC ParameterBecameRestrict { 510 public: 511 int method(int* param); 512 };"; 513 $SOURCE1 .= " 514 int ParameterBecameRestrict::method(int* param) { return 0; }"; 515 516 $HEADER2 .= " 517 class $DECL_SPEC ParameterBecameRestrict { 518 public: 519 int method(int* __restrict param); 520 };"; 521 $SOURCE2 .= " 522 int ParameterBecameRestrict::method(int* __restrict param) { return 0; }"; 523 524 # Parameter_Became_Non_Restrict 525 $HEADER1 .= " 526 class $DECL_SPEC ParameterBecameNonRestrict { 527 public: 528 int method(int* __restrict param); 529 };"; 530 $SOURCE1 .= " 531 int ParameterBecameNonRestrict::method(int* __restrict param) { return 0; }"; 532 533 $HEADER2 .= " 534 class $DECL_SPEC ParameterBecameNonRestrict { 535 public: 536 int method(int* param); 537 };"; 538 $SOURCE2 .= " 539 int ParameterBecameNonRestrict::method(int* param) { return 0; }"; 540 541 # Field_Became_Volatile 542 $HEADER1 .= " 543 class $DECL_SPEC FieldBecameVolatile { 544 public: 545 int method(int param); 546 int f; 547 };"; 548 $SOURCE1 .= " 549 int FieldBecameVolatile::method(int param) { return param; }"; 550 551 $HEADER2 .= " 552 class $DECL_SPEC FieldBecameVolatile { 553 public: 554 int method(int param); 555 volatile int f; 556 };"; 557 $SOURCE2 .= " 558 int FieldBecameVolatile::method(int param) { return param; }"; 559 560 # Field_Became_Non_Volatile 561 $HEADER1 .= " 562 class $DECL_SPEC FieldBecameNonVolatile { 563 public: 564 int method(int param); 565 volatile int f; 566 };"; 567 $SOURCE1 .= " 568 int FieldBecameNonVolatile::method(int param) { return param; }"; 569 570 $HEADER2 .= " 571 class $DECL_SPEC FieldBecameNonVolatile { 572 public: 573 int method(int param); 574 int f; 575 };"; 576 $SOURCE2 .= " 577 int FieldBecameNonVolatile::method(int param) { return param; }"; 578 579 # Field_Became_Mutable 580 $HEADER1 .= " 581 class $DECL_SPEC FieldBecameMutable { 582 public: 583 int method(int param); 584 int f; 585 };"; 586 $SOURCE1 .= " 587 int FieldBecameMutable::method(int param) { return param; }"; 588 589 $HEADER2 .= " 590 class $DECL_SPEC FieldBecameMutable { 591 public: 592 int method(int param); 593 mutable int f; 594 };"; 595 $SOURCE2 .= " 596 int FieldBecameMutable::method(int param) { return param; }"; 597 598 # Field_Became_Non_Mutable 599 $HEADER1 .= " 600 class $DECL_SPEC FieldBecameNonMutable { 601 public: 602 int method(int param); 603 mutable int f; 604 };"; 605 $SOURCE1 .= " 606 int FieldBecameNonMutable::method(int param) { return param; }"; 607 608 $HEADER2 .= " 609 class $DECL_SPEC FieldBecameNonMutable { 610 public: 611 int method(int param); 612 int f; 613 };"; 614 $SOURCE2 .= " 615 int FieldBecameNonMutable::method(int param) { return param; }"; 616 617 # Method_Became_Const 618 # Method_Became_Volatile 619 $HEADER1 .= " 620 class $DECL_SPEC MethodBecameConstVolatile { 621 public: 622 int method(int param); 623 };"; 624 $SOURCE1 .= " 625 int MethodBecameConstVolatile::method(int param) { return param; }"; 626 627 $HEADER2 .= " 628 class $DECL_SPEC MethodBecameConstVolatile { 629 public: 630 int method(int param) volatile const; 631 };"; 632 $SOURCE2 .= " 633 int MethodBecameConstVolatile::method(int param) volatile const { return param; }"; 634 635 # Method_Became_Const 636 $HEADER1 .= " 637 class $DECL_SPEC MethodBecameConst { 638 public: 639 int method(int param); 640 };"; 641 $SOURCE1 .= " 642 int MethodBecameConst::method(int param) { return param; }"; 643 644 $HEADER2 .= " 645 class $DECL_SPEC MethodBecameConst { 646 public: 647 int method(int param) const; 648 };"; 649 $SOURCE2 .= " 650 int MethodBecameConst::method(int param) const { return param; }"; 651 652 # Method_Became_Non_Const 653 $HEADER1 .= " 654 class $DECL_SPEC MethodBecameNonConst { 655 public: 656 int method(int param) const; 657 };"; 658 $SOURCE1 .= " 659 int MethodBecameNonConst::method(int param) const { return param; }"; 660 661 $HEADER2 .= " 662 class $DECL_SPEC MethodBecameNonConst { 663 public: 664 int method(int param); 665 };"; 666 $SOURCE2 .= " 667 int MethodBecameNonConst::method(int param) { return param; }"; 668 669 # Method_Became_Volatile 670 $HEADER1 .= " 671 class $DECL_SPEC MethodBecameVolatile { 672 public: 673 int method(int param); 674 };"; 675 $SOURCE1 .= " 676 int MethodBecameVolatile::method(int param) { return param; }"; 677 678 $HEADER2 .= " 679 class $DECL_SPEC MethodBecameVolatile { 680 public: 681 int method(int param) volatile; 682 };"; 683 $SOURCE2 .= " 684 int MethodBecameVolatile::method(int param) volatile { return param; }"; 685 686 # Virtual_Method_Position 687 # Multiple bases 688 $HEADER1 .= " 689 class $DECL_SPEC PrimaryBase 690 { 691 public: 692 virtual ~PrimaryBase(); 693 virtual void foo(); 694 }; 695 class $DECL_SPEC SecondaryBase 696 { 697 public: 698 virtual ~SecondaryBase(); 699 virtual void bar(); 700 }; 701 class UnsafeVirtualOverride: public PrimaryBase, public SecondaryBase 702 { 703 public: 704 UnsafeVirtualOverride(); 705 ~UnsafeVirtualOverride(); 706 void foo(); 707 };"; 708 $SOURCE1 .= " 709 PrimaryBase::~PrimaryBase() { } 710 void PrimaryBase::foo() { } 711 712 SecondaryBase::~SecondaryBase() { } 713 void SecondaryBase::bar() { } 714 715 UnsafeVirtualOverride::UnsafeVirtualOverride() { } 716 UnsafeVirtualOverride::~UnsafeVirtualOverride() { } 717 void UnsafeVirtualOverride::foo() { }"; 718 719 $HEADER2 .= " 720 class $DECL_SPEC PrimaryBase 721 { 722 public: 723 virtual ~PrimaryBase(); 724 virtual void foo(); 725 }; 726 class $DECL_SPEC SecondaryBase 727 { 728 public: 729 virtual ~SecondaryBase(); 730 virtual void bar(); 731 }; 732 class UnsafeVirtualOverride: public PrimaryBase, public SecondaryBase 733 { 734 public: 735 UnsafeVirtualOverride(); 736 ~UnsafeVirtualOverride(); 737 void foo(); 738 void bar(); 739 };"; 740 $SOURCE2 .= " 741 PrimaryBase::~PrimaryBase() { } 742 void PrimaryBase::foo() { } 743 744 SecondaryBase::~SecondaryBase() { } 745 void SecondaryBase::bar() { } 746 747 UnsafeVirtualOverride::UnsafeVirtualOverride() { } 748 UnsafeVirtualOverride::~UnsafeVirtualOverride() { } 749 void UnsafeVirtualOverride::foo() { } 750 void UnsafeVirtualOverride::bar() { }"; 751 752 # Removed_Interface (inline virtual d-tor) 753 $HEADER1 .= " 754 template <typename T> 755 class $DECL_SPEC BaseTemplate { 756 public: 757 BaseTemplate() { } 758 virtual int method(int param) { return param; }; 759 virtual ~BaseTemplate() { }; 760 }; 761 class $DECL_SPEC RemovedVirtualDestructor: public BaseTemplate<int> { 762 public: 763 RemovedVirtualDestructor() { }; 764 virtual int method2(int param); 765 };"; 766 $SOURCE1 .= " 767 int RemovedVirtualDestructor::method2(int param) { return param; }"; 768 769 $HEADER2 .= " 770 template <typename T> 771 class $DECL_SPEC BaseTemplate { 772 public: 773 BaseTemplate() { } 774 virtual int method(int param) { return param; }; 775 //virtual ~BaseTemplate() { }; 776 }; 777 class $DECL_SPEC RemovedVirtualDestructor: public BaseTemplate<int> { 778 public: 779 RemovedVirtualDestructor() { }; 780 virtual int method2(int param); 781 };"; 782 $SOURCE2 .= " 783 int RemovedVirtualDestructor::method2(int param) { return param; }"; 784 785 # Added_Virtual_Method_At_End 786 $HEADER1 .= " 787 class $DECL_SPEC DefaultConstructor { 788 public: 789 DefaultConstructor() { } 790 virtual int method(int param); 791 };"; 792 $SOURCE1 .= " 793 int DefaultConstructor::method(int param) { return param; }"; 794 795 $HEADER2 .= " 796 class $DECL_SPEC DefaultConstructor { 797 public: 798 DefaultConstructor() { } 799 virtual int method(int param); 800 virtual int addedMethod(int param); 801 };"; 802 $SOURCE2 .= " 803 int DefaultConstructor::method(int param) { return addedMethod(param); } 804 int DefaultConstructor::addedMethod(int param) { return param; }"; 805 806 # Added_Enum_Member 807 $HEADER1 .= " 808 enum AddedEnumMember { 809 OldMember 810 }; 811 $DECL_SPEC int addedEnumMember(enum AddedEnumMember param);"; 812 $SOURCE1 .= " 813 int addedEnumMember(enum AddedEnumMember param) { return 0; }"; 814 815 $HEADER2 .= " 816 enum AddedEnumMember { 817 OldMember, 818 NewMember 819 }; 820 $DECL_SPEC int addedEnumMember(enum AddedEnumMember param);"; 821 $SOURCE2 .= " 822 int addedEnumMember(enum AddedEnumMember param) { return 0; }"; 823 824 # Parameter_Type_Format (Safe) 825 $HEADER1 .= " 826 struct DType 827 { 828 int i; 829 double j; 830 }; 831 $DECL_SPEC int parameterTypeFormat_Safe(struct DType param);"; 832 $SOURCE1 .= " 833 int parameterTypeFormat_Safe(struct DType param) { return 0; }"; 834 835 $HEADER2 .= " 836 class DType 837 { 838 int i; 839 double j; 840 }; 841 $DECL_SPEC int parameterTypeFormat_Safe(class DType param);"; 842 $SOURCE2 .= " 843 int parameterTypeFormat_Safe(class DType param) { return 0; }"; 844 845 # Type_Became_Opaque (Struct) 846 $HEADER1 .= " 847 struct StructBecameOpaque 848 { 849 int i, j; 850 }; 851 $DECL_SPEC int structBecameOpaque(struct StructBecameOpaque* param);"; 852 $SOURCE1 .= " 853 int structBecameOpaque(struct StructBecameOpaque* param) { return 0; }"; 854 855 $HEADER2 .= " 856 struct StructBecameOpaque; 857 $DECL_SPEC int structBecameOpaque(struct StructBecameOpaque* param);"; 858 $SOURCE2 .= " 859 int structBecameOpaque(struct StructBecameOpaque* param) { return 0; }"; 860 861 # Type_Became_Opaque (Union) 862 $HEADER1 .= " 863 union UnionBecameOpaque 864 { 865 int i, j; 866 }; 867 $DECL_SPEC int unionBecameOpaque(union UnionBecameOpaque* param);"; 868 $SOURCE1 .= " 869 int unionBecameOpaque(union UnionBecameOpaque* param) { return 0; }"; 870 871 $HEADER2 .= " 872 union UnionBecameOpaque; 873 $DECL_SPEC int unionBecameOpaque(union UnionBecameOpaque* param);"; 874 $SOURCE2 .= " 875 int unionBecameOpaque(union UnionBecameOpaque* param) { return 0; }"; 876 877 # Field_Type_Format 878 $HEADER1 .= " 879 struct DType1 880 { 881 int i; 882 double j[7]; 883 }; 884 struct FieldTypeFormat 885 { 886 int i; 887 struct DType1 j; 888 }; 889 $DECL_SPEC int fieldTypeFormat(struct FieldTypeFormat param);"; 890 $SOURCE1 .= " 891 int fieldTypeFormat(struct FieldTypeFormat param) { return 0; }"; 892 893 $HEADER2 .= " 894 struct DType2 895 { 896 double i[7]; 897 int j; 898 }; 899 struct FieldTypeFormat 900 { 901 int i; 902 struct DType2 j; 903 }; 904 $DECL_SPEC int fieldTypeFormat(struct FieldTypeFormat param);"; 905 $SOURCE2 .= " 906 int fieldTypeFormat(struct FieldTypeFormat param) { return 0; }"; 907 908 # Field_Type_Format (func ptr) 909 $HEADER1 .= " 910 typedef void (*FuncPtr_Old) (int a); 911 struct FieldTypeFormat_FuncPtr 912 { 913 int i; 914 FuncPtr_Old j; 915 }; 916 $DECL_SPEC int fieldTypeFormat_FuncPtr(struct FieldTypeFormat_FuncPtr param);"; 917 $SOURCE1 .= " 918 int fieldTypeFormat_FuncPtr(struct FieldTypeFormat_FuncPtr param) { return 0; }"; 919 920 $HEADER2 .= " 921 typedef void (*FuncPtr_New) (int a, int b); 922 struct FieldTypeFormat_FuncPtr 923 { 924 int i; 925 FuncPtr_New j; 926 }; 927 $DECL_SPEC int fieldTypeFormat_FuncPtr(struct FieldTypeFormat_FuncPtr param);"; 928 $SOURCE2 .= " 929 int fieldTypeFormat_FuncPtr(struct FieldTypeFormat_FuncPtr param) { return 0; }"; 930 931 # Removed_Virtual_Method (inline) 932 $HEADER1 .= " 933 class $DECL_SPEC RemovedInlineVirtualFunction { 934 public: 935 RemovedInlineVirtualFunction(); 936 virtual int removedMethod(int param) { return 0; } 937 virtual int method(int param); 938 };"; 939 $SOURCE1 .= " 940 int RemovedInlineVirtualFunction::method(int param) { return param; } 941 RemovedInlineVirtualFunction::RemovedInlineVirtualFunction() { }"; 942 943 $HEADER2 .= " 944 class $DECL_SPEC RemovedInlineVirtualFunction { 945 public: 946 RemovedInlineVirtualFunction(); 947 virtual int method(int param); 948 };"; 949 $SOURCE2 .= " 950 int RemovedInlineVirtualFunction::method(int param) { return param; } 951 RemovedInlineVirtualFunction::RemovedInlineVirtualFunction() { }"; 952 953 # MethodPtr 954 $HEADER1 .= " 955 class TestMethodPtr { 956 public: 957 typedef void (TestMethodPtr::*Method)(int*); 958 Method _method; 959 TestMethodPtr(); 960 void method(); 961 };"; 962 $SOURCE1 .= " 963 TestMethodPtr::TestMethodPtr() { } 964 void TestMethodPtr::method() { }"; 965 966 $HEADER2 .= " 967 class TestMethodPtr { 968 public: 969 typedef void (TestMethodPtr::*Method)(int*, void*); 970 Method _method; 971 TestMethodPtr(); 972 void method(); 973 };"; 974 $SOURCE2 .= " 975 TestMethodPtr::TestMethodPtr() { } 976 void TestMethodPtr::method() { }"; 977 978 # FieldPtr 979 $HEADER1 .= " 980 class TestFieldPtr { 981 public: 982 typedef void* (TestFieldPtr::*Field); 983 Field _field; 984 TestFieldPtr(); 985 void method(void*); 986 };"; 987 $SOURCE1 .= " 988 TestFieldPtr::TestFieldPtr(){ } 989 void TestFieldPtr::method(void*) { }"; 990 991 $HEADER2 .= " 992 class TestFieldPtr { 993 public: 994 typedef int (TestFieldPtr::*Field); 995 Field _field; 996 TestFieldPtr(); 997 void method(void*); 998 };"; 999 $SOURCE2 .= " 1000 TestFieldPtr::TestFieldPtr(){ } 1001 void TestFieldPtr::method(void*) { }"; 1002 1003 # Removed_Symbol (Template Specializations) 1004 $HEADER1 .= " 1005 template <unsigned int _TP, typename AAA> 1006 class Template { 1007 public: 1008 char const *field; 1009 }; 1010 template <unsigned int _TP, typename AAA> 1011 class TestRemovedTemplate { 1012 public: 1013 char const *field; 1014 void method(int); 1015 }; 1016 template <> 1017 class TestRemovedTemplate<7, char> { 1018 public: 1019 char const *field; 1020 void method(int); 1021 };"; 1022 $SOURCE1 .= " 1023 void TestRemovedTemplate<7, char>::method(int){ }"; 1024 1025 # Removed_Symbol (Template Specializations) 1026 $HEADER1 .= " 1027 template <typename TName> 1028 int removedTemplateSpec(TName); 1029 1030 template <> int removedTemplateSpec<char>(char);"; 1031 $SOURCE1 .= " 1032 template <> int removedTemplateSpec<char>(char){return 0;}"; 1033 1034 # Removed_Field (Ref) 1035 $HEADER1 .= " 1036 struct TestRefChange { 1037 int a, b, c; 1038 }; 1039 $DECL_SPEC int paramRefChange(const TestRefChange & p1, int p2);"; 1040 $SOURCE1 .= " 1041 int paramRefChange(const TestRefChange & p1, int p2) { return p2; }"; 1042 1043 $HEADER2 .= " 1044 struct TestRefChange { 1045 int a, b; 1046 }; 1047 $DECL_SPEC int paramRefChange(const TestRefChange & p1, int p2);"; 1048 $SOURCE2 .= " 1049 int paramRefChange(const TestRefChange & p1, int p2) { return p2; }"; 1050 1051 # Removed_Parameter 1052 $HEADER1 .= " 1053 $DECL_SPEC int removedParameter(int param, int removed_param);"; 1054 $SOURCE1 .= " 1055 int removedParameter(int param, int removed_param) { return 0; }"; 1056 1057 $HEADER2 .= " 1058 $DECL_SPEC int removedParameter(int param);"; 1059 $SOURCE2 .= " 1060 int removedParameter(int param) { return 0; }"; 1061 1062 # Added_Parameter 1063 $HEADER1 .= " 1064 $DECL_SPEC int addedParameter(int param);"; 1065 $SOURCE1 .= " 1066 int addedParameter(int param) { return 0; }"; 1067 1068 $HEADER2 .= " 1069 $DECL_SPEC int addedParameter(int param, int added_param);"; 1070 $SOURCE2 .= " 1071 int addedParameter(int param, int added_param) { return 0; }"; 1072 1073 # Added 1074 $HEADER2 .= " 1075 typedef int (*FUNCPTR_TYPE)(int a, int b); 1076 $DECL_SPEC int addedFunc(FUNCPTR_TYPE*const** f);"; 1077 $SOURCE2 .= " 1078 int addedFunc(FUNCPTR_TYPE*const** f) { return 0; }"; 1079 1080 # Added (3) 1081 $HEADER2 .= " 1082 struct DStruct 1083 { 1084 int i, j, k; 1085 }; 1086 int addedFunc3(struct DStruct* p);"; 1087 $SOURCE2 .= " 1088 int addedFunc3(struct DStruct* p) { return 0; }"; 1089 1090 # Added_Virtual_Method 1091 $HEADER1 .= " 1092 class $DECL_SPEC AddedVirtualMethod { 1093 public: 1094 virtual int method(int param); 1095 };"; 1096 $SOURCE1 .= " 1097 int AddedVirtualMethod::method(int param) { return param; }"; 1098 1099 $HEADER2 .= " 1100 class $DECL_SPEC AddedVirtualMethod { 1101 public: 1102 virtual int addedMethod(int param); 1103 virtual int method(int param); 1104 };"; 1105 $SOURCE2 .= " 1106 int AddedVirtualMethod::addedMethod(int param) { 1107 return param; 1108 } 1109 int AddedVirtualMethod::method(int param) { return param; }"; 1110 1111 # Added_Virtual_Method (added "virtual" attribute) 1112 $HEADER1 .= " 1113 class $DECL_SPEC BecameVirtualMethod { 1114 public: 1115 int becameVirtual(int param); 1116 virtual int method(int param); 1117 };"; 1118 $SOURCE1 .= " 1119 int BecameVirtualMethod::becameVirtual(int param) { return param; } 1120 int BecameVirtualMethod::method(int param) { return param; }"; 1121 1122 $HEADER2 .= " 1123 class $DECL_SPEC BecameVirtualMethod { 1124 public: 1125 virtual int becameVirtual(int param); 1126 virtual int method(int param); 1127 };"; 1128 $SOURCE2 .= " 1129 int BecameVirtualMethod::becameVirtual(int param) { return param; } 1130 int BecameVirtualMethod::method(int param) { return param; }"; 1131 1132 # Added_Pure_Virtual_Method 1133 $HEADER1 .= " 1134 class $DECL_SPEC AddedPureVirtualMethod { 1135 public: 1136 virtual int method(int param); 1137 int otherMethod(int param); 1138 };"; 1139 $SOURCE1 .= " 1140 int AddedPureVirtualMethod::method(int param) { return param; } 1141 int AddedPureVirtualMethod::otherMethod(int param) { return param; }"; 1142 1143 $HEADER2 .= " 1144 class $DECL_SPEC AddedPureVirtualMethod { 1145 public: 1146 virtual int addedMethod(int param)=0; 1147 virtual int method(int param); 1148 int otherMethod(int param); 1149 };"; 1150 $SOURCE2 .= " 1151 int AddedPureVirtualMethod::method(int param) { return param; } 1152 int AddedPureVirtualMethod::otherMethod(int param) { return param; }"; 1153 1154 # Added_Virtual_Method_At_End (Safe) 1155 $HEADER1 .= " 1156 class $DECL_SPEC AddedVirtualMethodAtEnd { 1157 public: 1158 AddedVirtualMethodAtEnd(); 1159 int method1(int param); 1160 virtual int method2(int param); 1161 };"; 1162 $SOURCE1 .= " 1163 AddedVirtualMethodAtEnd::AddedVirtualMethodAtEnd() { } 1164 int AddedVirtualMethodAtEnd::method1(int param) { return param; } 1165 int AddedVirtualMethodAtEnd::method2(int param) { return param; }"; 1166 1167 $HEADER2 .= " 1168 class $DECL_SPEC AddedVirtualMethodAtEnd { 1169 public: 1170 AddedVirtualMethodAtEnd(); 1171 int method1(int param); 1172 virtual int method2(int param); 1173 virtual int addedMethod(int param); 1174 };"; 1175 $SOURCE2 .= " 1176 AddedVirtualMethodAtEnd::AddedVirtualMethodAtEnd() { } 1177 int AddedVirtualMethodAtEnd::method1(int param) { return param; } 1178 int AddedVirtualMethodAtEnd::method2(int param) { return param; } 1179 int AddedVirtualMethodAtEnd::addedMethod(int param) { return param; }"; 1180 1181 # Added_Virtual_Method_At_End (With Default Constructor) 1182 $HEADER1 .= " 1183 class $DECL_SPEC AddedVirtualMethodAtEnd_DefaultConstructor { 1184 public: 1185 int method1(int param); 1186 virtual int method2(int param); 1187 };"; 1188 $SOURCE1 .= " 1189 int AddedVirtualMethodAtEnd_DefaultConstructor::method1(int param) { return param; } 1190 int AddedVirtualMethodAtEnd_DefaultConstructor::method2(int param) { return param; }"; 1191 1192 $HEADER2 .= " 1193 class $DECL_SPEC AddedVirtualMethodAtEnd_DefaultConstructor { 1194 public: 1195 int method1(int param); 1196 virtual int method2(int param); 1197 virtual int addedMethod(int param); 1198 };"; 1199 $SOURCE2 .= " 1200 int AddedVirtualMethodAtEnd_DefaultConstructor::method1(int param) { return param; } 1201 int AddedVirtualMethodAtEnd_DefaultConstructor::method2(int param) { return param; } 1202 int AddedVirtualMethodAtEnd_DefaultConstructor::addedMethod(int param) { return param; }"; 1203 1204 # Added_First_Virtual_Method 1205 $HEADER1 .= " 1206 class $DECL_SPEC AddedFirstVirtualMethod { 1207 public: 1208 int method(int param); 1209 };"; 1210 $SOURCE1 .= " 1211 int AddedFirstVirtualMethod::method(int param) { return param; }"; 1212 1213 $HEADER2 .= " 1214 class $DECL_SPEC AddedFirstVirtualMethod { 1215 public: 1216 int method(int param); 1217 virtual int addedMethod(int param); 1218 };"; 1219 $SOURCE2 .= " 1220 int AddedFirstVirtualMethod::method(int param) { return param; } 1221 int AddedFirstVirtualMethod::addedMethod(int param) { return param; }"; 1222 1223 # Removed_Virtual_Method 1224 $HEADER1 .= " 1225 class $DECL_SPEC RemovedVirtualFunction { 1226 public: 1227 int a, b, c; 1228 virtual int removedMethod(int param); 1229 virtual int vMethod(int param); 1230 };"; 1231 $SOURCE1 .= " 1232 int RemovedVirtualFunction::removedMethod(int param) { return param; } 1233 int RemovedVirtualFunction::vMethod(int param) { return param; }"; 1234 1235 $HEADER2 .= " 1236 class $DECL_SPEC RemovedVirtualFunction { 1237 public: 1238 int a, b, c; 1239 int removedMethod(int param); 1240 virtual int vMethod(int param); 1241 };"; 1242 $SOURCE2 .= " 1243 int RemovedVirtualFunction::removedMethod(int param) { return param; } 1244 int RemovedVirtualFunction::vMethod(int param) { return param; }"; 1245 1246 # Removed_Virtual_Method (Pure, From the End) 1247 $HEADER1 .= " 1248 class $DECL_SPEC RemovedPureVirtualMethodFromEnd { 1249 public: 1250 virtual int method(int param); 1251 virtual int removedMethod(int param)=0; 1252 };"; 1253 $SOURCE1 .= " 1254 int RemovedPureVirtualMethodFromEnd::method(int param) { return param; } 1255 int RemovedPureVirtualMethodFromEnd::removedMethod(int param) { return param; }"; 1256 1257 $HEADER2 .= " 1258 class $DECL_SPEC RemovedPureVirtualMethodFromEnd 1259 { 1260 public: 1261 virtual int method(int param); 1262 int removedMethod(int param); 1263 };"; 1264 $SOURCE2 .= " 1265 int RemovedPureVirtualMethodFromEnd::method(int param) { return param; } 1266 int RemovedPureVirtualMethodFromEnd::removedMethod(int param) { return param; }"; 1267 1268 # Removed_Symbol (Pure with Implementation) 1269 $HEADER1 .= " 1270 class $DECL_SPEC RemovedPureSymbol { 1271 public: 1272 virtual int method(int param); 1273 virtual int removedMethod(int param)=0; 1274 };"; 1275 $SOURCE1 .= " 1276 int RemovedPureSymbol::method(int param) { return param; } 1277 int RemovedPureSymbol::removedMethod(int param) { return param; }"; 1278 1279 $HEADER2 .= " 1280 class $DECL_SPEC RemovedPureSymbol 1281 { 1282 public: 1283 virtual int method(int param); 1284 };"; 1285 $SOURCE2 .= " 1286 int RemovedPureSymbol::method(int param) { return param; }"; 1287 1288 # Removed_Virtual_Method (From the End) 1289 $HEADER1 .= " 1290 class $DECL_SPEC RemovedVirtualMethodFromEnd { 1291 public: 1292 virtual int method(int param); 1293 virtual int removedMethod(int param); 1294 };"; 1295 $SOURCE1 .= " 1296 int RemovedVirtualMethodFromEnd::method(int param) { return param; } 1297 int RemovedVirtualMethodFromEnd::removedMethod(int param) { return param; }"; 1298 1299 $HEADER2 .= " 1300 class $DECL_SPEC RemovedVirtualMethodFromEnd 1301 { 1302 public: 1303 virtual int method(int param); 1304 int removedMethod(int param); 1305 };"; 1306 $SOURCE2 .= " 1307 int RemovedVirtualMethodFromEnd::method(int param) { return param; } 1308 int RemovedVirtualMethodFromEnd::removedMethod(int param) { return param; }"; 1309 1310 # Removed_Virtual_Method 1311 $HEADER1 .= " 1312 class $DECL_SPEC RemovedVirtualSymbol { 1313 public: 1314 virtual int method(int param); 1315 virtual int removedMethod(int param); 1316 };"; 1317 $SOURCE1 .= " 1318 int RemovedVirtualSymbol::method(int param) { return param; } 1319 int RemovedVirtualSymbol::removedMethod(int param) { return param; }"; 1320 1321 $HEADER2 .= " 1322 class $DECL_SPEC RemovedVirtualSymbol 1323 { 1324 public: 1325 virtual int method(int param); 1326 };"; 1327 $SOURCE2 .= " 1328 int RemovedVirtualSymbol::method(int param) { return param; }"; 1329 1330 # Removed_Virtual_Method (Private) 1331 $HEADER1 .= " 1332 class $DECL_SPEC RemovedPrivateVirtualSymbol { 1333 public: 1334 virtual int method(int param); 1335 private: 1336 virtual int removedMethod(int param); 1337 };"; 1338 $SOURCE1 .= " 1339 int RemovedPrivateVirtualSymbol::method(int param) { return param; } 1340 int RemovedPrivateVirtualSymbol::removedMethod(int param) { return param; }"; 1341 1342 $HEADER2 .= " 1343 class $DECL_SPEC RemovedPrivateVirtualSymbol 1344 { 1345 public: 1346 virtual int method(int param); 1347 };"; 1348 $SOURCE2 .= " 1349 int RemovedPrivateVirtualSymbol::method(int param) { return param; }"; 1350 1351 # Added_Virtual_Method (Private) 1352 $HEADER1 .= " 1353 class $DECL_SPEC AddedPrivateVirtualSymbol 1354 { 1355 public: 1356 AddedPrivateVirtualSymbol(); 1357 virtual int method(int param); 1358 }; 1359 1360 class $DECL_SPEC AddedPrivateVirtualSymbol_Derived: public AddedPrivateVirtualSymbol 1361 { 1362 public: 1363 virtual int method1(int param); 1364 };"; 1365 $SOURCE1 .= " 1366 AddedPrivateVirtualSymbol::AddedPrivateVirtualSymbol() {}; 1367 int AddedPrivateVirtualSymbol::method(int param) { return param; } 1368 int AddedPrivateVirtualSymbol_Derived::method1(int param) { return param; }"; 1369 1370 $HEADER2 .= " 1371 class $DECL_SPEC AddedPrivateVirtualSymbol { 1372 public: 1373 AddedPrivateVirtualSymbol(); 1374 virtual int method(int param); 1375 private: 1376 virtual int addedMethod(int param); 1377 }; 1378 1379 class $DECL_SPEC AddedPrivateVirtualSymbol_Derived: public AddedPrivateVirtualSymbol 1380 { 1381 public: 1382 virtual int method1(int param); 1383 };"; 1384 $SOURCE2 .= " 1385 AddedPrivateVirtualSymbol::AddedPrivateVirtualSymbol() {}; 1386 int AddedPrivateVirtualSymbol::method(int param) { return param; } 1387 int AddedPrivateVirtualSymbol::addedMethod(int param) { return param; } 1388 int AddedPrivateVirtualSymbol_Derived::method1(int param) { return param; }"; 1389 1390 # Removed and added virtual method 1391 $HEADER1 .= " 1392 class $DECL_SPEC RemovedAddedVirtualSymbol { 1393 public: 1394 virtual int removedMethod(int param); 1395 };"; 1396 $SOURCE1 .= " 1397 int RemovedAddedVirtualSymbol::removedMethod(int param) { return param; }"; 1398 1399 $HEADER2 .= " 1400 class $DECL_SPEC RemovedAddedVirtualSymbol 1401 { 1402 public: 1403 virtual int addedMethod(int param); 1404 };"; 1405 $SOURCE2 .= " 1406 int RemovedAddedVirtualSymbol::addedMethod(int param) { return param; }"; 1407 1408 # Removed_Last_Virtual_Method 1409 $HEADER1 .= " 1410 class $DECL_SPEC RemovedLastVirtualMethod 1411 { 1412 public: 1413 int method(int param); 1414 virtual int removedMethod(int param); 1415 };"; 1416 $SOURCE1 .= " 1417 int RemovedLastVirtualMethod::method(int param) { return param; }"; 1418 $SOURCE1 .= " 1419 int RemovedLastVirtualMethod::removedMethod(int param) { return param; }"; 1420 1421 $HEADER2 .= " 1422 class $DECL_SPEC RemovedLastVirtualMethod 1423 { 1424 public: 1425 int method(int param); 1426 int removedMethod(int param); 1427 };"; 1428 $SOURCE2 .= " 1429 int RemovedLastVirtualMethod::method(int param) { return param; }"; 1430 $SOURCE2 .= " 1431 int RemovedLastVirtualMethod::removedMethod(int param) { return param; }"; 1432 1433 # Removed_Last_Virtual_Method 1434 $HEADER1 .= " 1435 class $DECL_SPEC RemovedLastVirtualSymbol 1436 { 1437 public: 1438 int method(int param); 1439 virtual int removedMethod(int param); 1440 };"; 1441 $SOURCE1 .= " 1442 int RemovedLastVirtualSymbol::method(int param) { return param; }"; 1443 $SOURCE1 .= " 1444 int RemovedLastVirtualSymbol::removedMethod(int param) { return param; }"; 1445 1446 $HEADER2 .= " 1447 class $DECL_SPEC RemovedLastVirtualSymbol 1448 { 1449 public: 1450 int method(int param); 1451 };"; 1452 $SOURCE2 .= " 1453 int RemovedLastVirtualSymbol::method(int param) { return param; }"; 1454 1455 # Virtual_Table_Size 1456 $HEADER1 .= " 1457 class $DECL_SPEC VirtualTableSize 1458 { 1459 public: 1460 virtual int method1(int param); 1461 virtual int method2(int param); 1462 }; 1463 class $DECL_SPEC VirtualTableSize_SubClass: public VirtualTableSize 1464 { 1465 public: 1466 virtual int method3(int param); 1467 virtual int method4(int param); 1468 };"; 1469 $SOURCE1 .= " 1470 int VirtualTableSize::method1(int param) { return param; } 1471 int VirtualTableSize::method2(int param) { return param; } 1472 int VirtualTableSize_SubClass::method3(int param) { return param; } 1473 int VirtualTableSize_SubClass::method4(int param) { return param; }"; 1474 1475 $HEADER2 .= " 1476 class $DECL_SPEC VirtualTableSize 1477 { 1478 public: 1479 virtual int method1(int param); 1480 virtual int method2(int param); 1481 virtual int addedMethod(int param); 1482 }; 1483 class $DECL_SPEC VirtualTableSize_SubClass: public VirtualTableSize 1484 { 1485 public: 1486 virtual int method3(int param); 1487 virtual int method4(int param); 1488 };"; 1489 $SOURCE2 .= " 1490 int VirtualTableSize::method1(int param) { return param; } 1491 int VirtualTableSize::method2(int param) { return param; } 1492 int VirtualTableSize::addedMethod(int param) { return param; } 1493 int VirtualTableSize_SubClass::method3(int param) { return param; } 1494 int VirtualTableSize_SubClass::method4(int param) { return param; }"; 1495 1496 # Virtual_Method_Position 1497 $HEADER1 .= " 1498 class $DECL_SPEC VirtualMethodPosition 1499 { 1500 public: 1501 virtual int method1(int param); 1502 virtual int method2(int param); 1503 };"; 1504 $SOURCE1 .= " 1505 int VirtualMethodPosition::method1(int param) { return param; }"; 1506 $SOURCE1 .= " 1507 int VirtualMethodPosition::method2(int param) { return param; }"; 1508 1509 $HEADER2 .= " 1510 class $DECL_SPEC VirtualMethodPosition 1511 { 1512 public: 1513 virtual int method2(int param); 1514 virtual int method1(int param); 1515 };"; 1516 $SOURCE2 .= " 1517 int VirtualMethodPosition::method1(int param) { return param; }"; 1518 $SOURCE2 .= " 1519 int VirtualMethodPosition::method2(int param) { return param; }"; 1520 1521 # Pure_Virtual_Method_Position 1522 $HEADER1 .= " 1523 class $DECL_SPEC PureVirtualFunctionPosition { 1524 public: 1525 virtual int method1(int param)=0; 1526 virtual int method2(int param)=0; 1527 int method3(int param); 1528 };"; 1529 $SOURCE1 .= " 1530 int PureVirtualFunctionPosition::method3(int param) { return method1(7)+method2(7); }"; 1531 1532 $HEADER2 .= " 1533 class $DECL_SPEC PureVirtualFunctionPosition { 1534 public: 1535 virtual int method2(int param)=0; 1536 virtual int method1(int param)=0; 1537 int method3(int param); 1538 };"; 1539 $SOURCE2 .= " 1540 int PureVirtualFunctionPosition::method3(int param) { return method1(7)+method2(7); }"; 1541 1542 # Virtual_Method_Position 1543 $HEADER1 .= " 1544 class $DECL_SPEC VirtualFunctionPosition { 1545 public: 1546 virtual int method1(int param); 1547 virtual int method2(int param); 1548 };"; 1549 $SOURCE1 .= " 1550 int VirtualFunctionPosition::method1(int param) { return 1; } 1551 int VirtualFunctionPosition::method2(int param) { return 2; }"; 1552 1553 $HEADER2 .= " 1554 class $DECL_SPEC VirtualFunctionPosition { 1555 public: 1556 virtual int method2(int param); 1557 virtual int method1(int param); 1558 };"; 1559 $SOURCE2 .= " 1560 int VirtualFunctionPosition::method1(int param) { return 1; } 1561 int VirtualFunctionPosition::method2(int param) { return 2; }"; 1562 1563 # Virtual_Method_Position (safe) 1564 $HEADER1 .= " 1565 class $DECL_SPEC VirtualFunctionPositionSafe_Base { 1566 public: 1567 virtual int method1(int param); 1568 virtual int method2(int param); 1569 }; 1570 class $DECL_SPEC VirtualFunctionPositionSafe: public VirtualFunctionPositionSafe_Base { 1571 public: 1572 virtual int method1(int param); 1573 virtual int method2(int param); 1574 };"; 1575 $SOURCE1 .= " 1576 int VirtualFunctionPositionSafe_Base::method1(int param) { return param; } 1577 int VirtualFunctionPositionSafe_Base::method2(int param) { return param; } 1578 int VirtualFunctionPositionSafe::method1(int param) { return param; } 1579 int VirtualFunctionPositionSafe::method2(int param) { return param; }"; 1580 1581 $HEADER2 .= " 1582 class $DECL_SPEC VirtualFunctionPositionSafe_Base { 1583 public: 1584 virtual int method1(int param); 1585 virtual int method2(int param); 1586 }; 1587 class $DECL_SPEC VirtualFunctionPositionSafe: public VirtualFunctionPositionSafe_Base { 1588 public: 1589 virtual int method2(int param); 1590 virtual int method1(int param); 1591 };"; 1592 $SOURCE2 .= " 1593 int VirtualFunctionPositionSafe_Base::method1(int param) { return param; } 1594 int VirtualFunctionPositionSafe_Base::method2(int param) { return param; } 1595 int VirtualFunctionPositionSafe::method1(int param) { return param; } 1596 int VirtualFunctionPositionSafe::method2(int param) { return param; }"; 1597 1598 # Overridden_Virtual_Method 1599 $HEADER1 .= " 1600 class $DECL_SPEC OverriddenVirtualMethod_Base { 1601 public: 1602 virtual int method1(int param); 1603 virtual int method2(int param); 1604 }; 1605 class $DECL_SPEC OverriddenVirtualMethod: public OverriddenVirtualMethod_Base { 1606 public: 1607 OverriddenVirtualMethod(); 1608 virtual int method3(int param); 1609 };"; 1610 $SOURCE1 .= " 1611 int OverriddenVirtualMethod_Base::method1(int param) { return param; } 1612 int OverriddenVirtualMethod_Base::method2(int param) { return param; } 1613 OverriddenVirtualMethod::OverriddenVirtualMethod() {} 1614 int OverriddenVirtualMethod::method3(int param) { return param; }"; 1615 1616 $HEADER2 .= " 1617 class $DECL_SPEC OverriddenVirtualMethod_Base { 1618 public: 1619 virtual int method1(int param); 1620 virtual int method2(int param); 1621 }; 1622 class $DECL_SPEC OverriddenVirtualMethod:public OverriddenVirtualMethod_Base { 1623 OverriddenVirtualMethod(); 1624 virtual int method2(int param); 1625 virtual int method3(int param); 1626 };"; 1627 $SOURCE2 .= " 1628 int OverriddenVirtualMethod_Base::method1(int param) { return param; } 1629 int OverriddenVirtualMethod_Base::method2(int param) { return param; } 1630 OverriddenVirtualMethod::OverriddenVirtualMethod() {} 1631 int OverriddenVirtualMethod::method2(int param) { return param; } 1632 int OverriddenVirtualMethod::method3(int param) { return param; }"; 1633 1634 # Overridden_Virtual_Method_B (+ removed) 1635 $HEADER1 .= " 1636 1637 class $DECL_SPEC OverriddenVirtualMethodB: public OverriddenVirtualMethod_Base { 1638 public: 1639 OverriddenVirtualMethodB(); 1640 virtual int method2(int param); 1641 virtual int method3(int param); 1642 };"; 1643 $SOURCE1 .= " 1644 OverriddenVirtualMethodB::OverriddenVirtualMethodB() {} 1645 int OverriddenVirtualMethodB::method2(int param) { return param; } 1646 int OverriddenVirtualMethodB::method3(int param) { return param; }"; 1647 1648 $HEADER2 .= " 1649 1650 class $DECL_SPEC OverriddenVirtualMethodB:public OverriddenVirtualMethod_Base { 1651 public: 1652 OverriddenVirtualMethodB(); 1653 virtual int method3(int param); 1654 };"; 1655 $SOURCE2 .= " 1656 OverriddenVirtualMethodB::OverriddenVirtualMethodB() {} 1657 int OverriddenVirtualMethodB::method3(int param) { return param; }"; 1658 1659 # Size 1660 $HEADER1 .= " 1661 struct $DECL_SPEC TypeSize 1662 { 1663 public: 1664 TypeSize method(TypeSize param); 1665 int i[5]; 1666 long j; 1667 double k; 1668 TypeSize* p; 1669 };"; 1670 $SOURCE1 .= " 1671 TypeSize TypeSize::method(TypeSize param) { return param; }"; 1672 1673 $HEADER2 .= " 1674 struct $DECL_SPEC TypeSize 1675 { 1676 public: 1677 TypeSize method(TypeSize param); 1678 int i[15]; 1679 long j; 1680 double k; 1681 TypeSize* p; 1682 int added_member; 1683 };"; 1684 $SOURCE2 .= " 1685 TypeSize TypeSize::method(TypeSize param) { return param; }"; 1686 1687 # Size_Of_Allocable_Class_Increased 1688 $HEADER1 .= " 1689 class $DECL_SPEC AllocableClassSize 1690 { 1691 public: 1692 AllocableClassSize(); 1693 int method(); 1694 double p[5]; 1695 };"; 1696 $SOURCE1 .= " 1697 AllocableClassSize::AllocableClassSize() { }"; 1698 $SOURCE1 .= " 1699 int AllocableClassSize::method() { return 0; }"; 1700 1701 $HEADER2 .= " 1702 struct $DECL_SPEC AllocableClassSize 1703 { 1704 public: 1705 AllocableClassSize(); 1706 int method(); 1707 double p[15]; 1708 };"; 1709 $SOURCE2 .= " 1710 AllocableClassSize::AllocableClassSize() { }"; 1711 $SOURCE2 .= " 1712 int AllocableClassSize::method() { return 0; }"; 1713 1714 # Size_Of_Allocable_Class_Decreased (decreased size, has derived class, has public members) 1715 $HEADER1 .= " 1716 class $DECL_SPEC DecreasedClassSize 1717 { 1718 public: 1719 DecreasedClassSize(); 1720 int method(); 1721 double p[15]; 1722 };"; 1723 $SOURCE1 .= " 1724 DecreasedClassSize::DecreasedClassSize() { }"; 1725 $SOURCE1 .= " 1726 int DecreasedClassSize::method() { return 0; }"; 1727 $HEADER1 .= " 1728 class $DECL_SPEC DecreasedClassSize_SubClass: public DecreasedClassSize 1729 { 1730 public: 1731 DecreasedClassSize_SubClass(); 1732 int method(); 1733 int f; 1734 };"; 1735 $SOURCE1 .= " 1736 DecreasedClassSize_SubClass::DecreasedClassSize_SubClass() { f=7; }"; 1737 $SOURCE1 .= " 1738 int DecreasedClassSize_SubClass::method() { return f; }"; 1739 1740 $HEADER2 .= " 1741 struct $DECL_SPEC DecreasedClassSize 1742 { 1743 public: 1744 DecreasedClassSize(); 1745 int method(); 1746 double p[5]; 1747 };"; 1748 $SOURCE2 .= " 1749 DecreasedClassSize::DecreasedClassSize() { }"; 1750 $SOURCE2 .= " 1751 int DecreasedClassSize::method() { return 0; }"; 1752 $HEADER2 .= " 1753 class $DECL_SPEC DecreasedClassSize_SubClass: public DecreasedClassSize 1754 { 1755 public: 1756 DecreasedClassSize_SubClass(); 1757 int method(); 1758 int f; 1759 };"; 1760 $SOURCE2 .= " 1761 DecreasedClassSize_SubClass::DecreasedClassSize_SubClass() { f=7; }"; 1762 $SOURCE2 .= " 1763 int DecreasedClassSize_SubClass::method() { return f; }"; 1764 1765 # Size_Of_Copying_Class 1766 $HEADER1 .= " 1767 class $DECL_SPEC CopyingClassSize 1768 { 1769 public: 1770 int method(); 1771 int p[5]; 1772 };"; 1773 $SOURCE1 .= " 1774 int CopyingClassSize::method() { return p[4]; }"; 1775 1776 $HEADER2 .= " 1777 struct $DECL_SPEC CopyingClassSize 1778 { 1779 public: 1780 int method(); 1781 int p[15]; 1782 };"; 1783 $SOURCE2 .= " 1784 int CopyingClassSize::method() { return p[10]; }"; 1785 1786 # Base_Class_Became_Virtually_Inherited 1787 $HEADER1 .= " 1788 class $DECL_SPEC BecameVirtualBase 1789 { 1790 public: 1791 BecameVirtualBase(); 1792 int method(); 1793 double p[5]; 1794 };"; 1795 $SOURCE1 .= " 1796 BecameVirtualBase::BecameVirtualBase() { }"; 1797 $SOURCE1 .= " 1798 int BecameVirtualBase::method() { return 0; }"; 1799 $HEADER1 .= " 1800 class $DECL_SPEC AddedVirtualBase1:public BecameVirtualBase 1801 { 1802 public: 1803 AddedVirtualBase1(); 1804 int method(); 1805 };"; 1806 $SOURCE1 .= " 1807 AddedVirtualBase1::AddedVirtualBase1() { }"; 1808 $SOURCE1 .= " 1809 int AddedVirtualBase1::method() { return 0; }"; 1810 $HEADER1 .= " 1811 class $DECL_SPEC AddedVirtualBase2: public BecameVirtualBase 1812 { 1813 public: 1814 AddedVirtualBase2(); 1815 int method(); 1816 };"; 1817 $SOURCE1 .= " 1818 AddedVirtualBase2::AddedVirtualBase2() { }"; 1819 $SOURCE1 .= " 1820 int AddedVirtualBase2::method() { return 0; }"; 1821 $HEADER1 .= " 1822 class $DECL_SPEC BaseClassBecameVirtuallyInherited:public AddedVirtualBase1, public AddedVirtualBase2 1823 { 1824 public: 1825 BaseClassBecameVirtuallyInherited(); 1826 };"; 1827 $SOURCE1 .= " 1828 BaseClassBecameVirtuallyInherited::BaseClassBecameVirtuallyInherited() { }"; 1829 1830 $HEADER2 .= " 1831 class $DECL_SPEC BecameVirtualBase 1832 { 1833 public: 1834 BecameVirtualBase(); 1835 int method(); 1836 double p[5]; 1837 };"; 1838 $SOURCE2 .= " 1839 BecameVirtualBase::BecameVirtualBase() { }"; 1840 $SOURCE2 .= " 1841 int BecameVirtualBase::method() { return 0; }"; 1842 $HEADER2 .= " 1843 class $DECL_SPEC AddedVirtualBase1:public virtual BecameVirtualBase 1844 { 1845 public: 1846 AddedVirtualBase1(); 1847 int method(); 1848 };"; 1849 $SOURCE2 .= " 1850 AddedVirtualBase1::AddedVirtualBase1() { }"; 1851 $SOURCE2 .= " 1852 int AddedVirtualBase1::method() { return 0; }"; 1853 $HEADER2 .= " 1854 class $DECL_SPEC AddedVirtualBase2: public virtual BecameVirtualBase 1855 { 1856 public: 1857 AddedVirtualBase2(); 1858 int method(); 1859 };"; 1860 $SOURCE2 .= " 1861 AddedVirtualBase2::AddedVirtualBase2() { }"; 1862 $SOURCE2 .= " 1863 int AddedVirtualBase2::method() { return 0; }"; 1864 $HEADER2 .= " 1865 class $DECL_SPEC BaseClassBecameVirtuallyInherited:public AddedVirtualBase1, public AddedVirtualBase2 1866 { 1867 public: 1868 BaseClassBecameVirtuallyInherited(); 1869 };"; 1870 $SOURCE2 .= " 1871 BaseClassBecameVirtuallyInherited::BaseClassBecameVirtuallyInherited() { }"; 1872 1873 # Added_Base_Class, Removed_Base_Class 1874 $HEADER1 .= " 1875 class $DECL_SPEC BaseClass 1876 { 1877 public: 1878 BaseClass(); 1879 int method(); 1880 double p[5]; 1881 }; 1882 class $DECL_SPEC RemovedBaseClass 1883 { 1884 public: 1885 RemovedBaseClass(); 1886 int method(); 1887 }; 1888 class $DECL_SPEC ChangedBaseClass:public BaseClass, public RemovedBaseClass 1889 { 1890 public: 1891 ChangedBaseClass(); 1892 };"; 1893 $SOURCE1 .= " 1894 BaseClass::BaseClass() { } 1895 int BaseClass::method() { return 0; } 1896 RemovedBaseClass::RemovedBaseClass() { } 1897 int RemovedBaseClass::method() { return 0; } 1898 ChangedBaseClass::ChangedBaseClass() { }"; 1899 1900 $HEADER2 .= " 1901 class $DECL_SPEC BaseClass 1902 { 1903 public: 1904 BaseClass(); 1905 int method(); 1906 double p[5]; 1907 }; 1908 class $DECL_SPEC AddedBaseClass 1909 { 1910 public: 1911 AddedBaseClass(); 1912 int method(); 1913 }; 1914 class $DECL_SPEC ChangedBaseClass:public BaseClass, public AddedBaseClass 1915 { 1916 public: 1917 ChangedBaseClass(); 1918 };"; 1919 $SOURCE2 .= " 1920 BaseClass::BaseClass() { } 1921 int BaseClass::method() { return 0; } 1922 AddedBaseClass::AddedBaseClass() { } 1923 int AddedBaseClass::method() { return 0; } 1924 ChangedBaseClass::ChangedBaseClass() { }"; 1925 1926 # Added_Base_Class_And_Shift, Removed_Base_Class_And_Shift 1927 $HEADER1 .= " 1928 struct $DECL_SPEC BaseClass2 1929 { 1930 BaseClass2(); 1931 int method(); 1932 double p[15]; 1933 }; 1934 class $DECL_SPEC ChangedBaseClassAndSize:public BaseClass 1935 { 1936 public: 1937 ChangedBaseClassAndSize(); 1938 };"; 1939 $SOURCE1 .= " 1940 BaseClass2::BaseClass2() { } 1941 int BaseClass2::method() { return 0; } 1942 ChangedBaseClassAndSize::ChangedBaseClassAndSize() { }"; 1943 1944 $HEADER2 .= " 1945 struct $DECL_SPEC BaseClass2 1946 { 1947 BaseClass2(); 1948 int method(); 1949 double p[15]; 1950 }; 1951 class $DECL_SPEC ChangedBaseClassAndSize:public BaseClass2 1952 { 1953 public: 1954 ChangedBaseClassAndSize(); 1955 };"; 1956 $SOURCE2 .= " 1957 BaseClass2::BaseClass2() { } 1958 int BaseClass2::method() { return 0; } 1959 ChangedBaseClassAndSize::ChangedBaseClassAndSize() { }"; 1960 1961 # Added_Field_And_Size 1962 $HEADER1 .= " 1963 struct $DECL_SPEC AddedFieldAndSize 1964 { 1965 int method(AddedFieldAndSize param); 1966 double i, j, k; 1967 AddedFieldAndSize* p; 1968 };"; 1969 $SOURCE1 .= " 1970 int AddedFieldAndSize::method(AddedFieldAndSize param) { return 0; }"; 1971 1972 $HEADER2 .= " 1973 struct $DECL_SPEC AddedFieldAndSize 1974 { 1975 int method(AddedFieldAndSize param); 1976 double i, j, k; 1977 AddedFieldAndSize* p; 1978 int added_member1; 1979 long long added_member2; 1980 };"; 1981 $SOURCE2 .= " 1982 int AddedFieldAndSize::method(AddedFieldAndSize param) { return 0; }"; 1983 1984 # Added_Field 1985 $HEADER1 .= " 1986 class $DECL_SPEC ObjectAddedMember 1987 { 1988 public: 1989 int method(int param); 1990 double i, j, k; 1991 AddedFieldAndSize* p; 1992 };"; 1993 $SOURCE1 .= " 1994 int ObjectAddedMember::method(int param) { return param; }"; 1995 1996 $HEADER2 .= " 1997 class $DECL_SPEC ObjectAddedMember 1998 { 1999 public: 2000 int method(int param); 2001 double i, j, k; 2002 AddedFieldAndSize* p; 2003 int added_member1; 2004 long long added_member2; 2005 };"; 2006 $SOURCE2 .= " 2007 int ObjectAddedMember::method(int param) { return param; }"; 2008 2009 # Added_Field (safe) 2010 $HEADER1 .= " 2011 struct $DECL_SPEC AddedBitfield 2012 { 2013 int method(AddedBitfield param); 2014 double i, j, k; 2015 int b1 : 32; 2016 int b2 : 31; 2017 AddedBitfield* p; 2018 };"; 2019 $SOURCE1 .= " 2020 int AddedBitfield::method(AddedBitfield param) { return 0; }"; 2021 2022 $HEADER2 .= " 2023 struct $DECL_SPEC AddedBitfield 2024 { 2025 int method(AddedBitfield param); 2026 double i, j, k; 2027 int b1 : 32; 2028 int b2 : 31; 2029 int added_bitfield : 1; 2030 int added_bitfield2 : 1; 2031 AddedBitfield* p; 2032 };"; 2033 $SOURCE2 .= " 2034 int AddedBitfield::method(AddedBitfield param) { return 0; }"; 2035 2036 # Bit_Field_Size 2037 $HEADER1 .= " 2038 struct $DECL_SPEC BitfieldSize 2039 { 2040 int method(BitfieldSize param); 2041 short changed_bitfield : 1; 2042 };"; 2043 $SOURCE1 .= " 2044 int BitfieldSize::method(BitfieldSize param) { return 0; }"; 2045 2046 $HEADER2 .= " 2047 struct $DECL_SPEC BitfieldSize 2048 { 2049 int method(BitfieldSize param); 2050 short changed_bitfield : 7; 2051 };"; 2052 $SOURCE2 .= " 2053 int BitfieldSize::method(BitfieldSize param) { return 0; }"; 2054 2055 # Removed_Field 2056 $HEADER1 .= " 2057 struct $DECL_SPEC RemovedBitfield 2058 { 2059 int method(RemovedBitfield param); 2060 double i, j, k; 2061 int b1 : 32; 2062 int b2 : 31; 2063 int removed_bitfield : 1; 2064 RemovedBitfield* p; 2065 };"; 2066 $SOURCE1 .= " 2067 int RemovedBitfield::method(RemovedBitfield param) { return 0; }"; 2068 2069 $HEADER2 .= " 2070 struct $DECL_SPEC RemovedBitfield 2071 { 2072 int method(RemovedBitfield param); 2073 double i, j, k; 2074 int b1 : 32; 2075 int b2 : 31; 2076 RemovedBitfield* p; 2077 };"; 2078 $SOURCE2 .= " 2079 int RemovedBitfield::method(RemovedBitfield param) { return 0; }"; 2080 2081 # Removed_Middle_Field 2082 $HEADER1 .= " 2083 struct $DECL_SPEC RemovedMiddleBitfield 2084 { 2085 int method(RemovedMiddleBitfield param); 2086 double i, j, k; 2087 int b1 : 32; 2088 int removed_middle_bitfield : 1; 2089 int b2 : 31; 2090 RemovedMiddleBitfield* p; 2091 };"; 2092 $SOURCE1 .= " 2093 int RemovedMiddleBitfield::method(RemovedMiddleBitfield param) { return 0; }"; 2094 2095 $HEADER2 .= " 2096 struct $DECL_SPEC RemovedMiddleBitfield 2097 { 2098 int method(RemovedMiddleBitfield param); 2099 double i, j, k; 2100 int b1 : 32; 2101 int b2 : 31; 2102 RemovedMiddleBitfield* p; 2103 };"; 2104 $SOURCE2 .= " 2105 int RemovedMiddleBitfield::method(RemovedMiddleBitfield param) { return 0; }"; 2106 2107 # Added_Middle_Field_And_Size 2108 $HEADER1 .= " 2109 struct $DECL_SPEC AddedMiddleFieldAndSize 2110 { 2111 int method(AddedMiddleFieldAndSize param); 2112 int i; 2113 long j; 2114 double k; 2115 AddedMiddleFieldAndSize* p; 2116 };"; 2117 $SOURCE1 .= " 2118 int AddedMiddleFieldAndSize::method(AddedMiddleFieldAndSize param) { return 0; }"; 2119 2120 $HEADER2 .= " 2121 struct $DECL_SPEC AddedMiddleFieldAndSize 2122 { 2123 int method(AddedMiddleFieldAndSize param); 2124 int i; 2125 int added_middle_member; 2126 long j; 2127 double k; 2128 AddedMiddleFieldAndSize* p; 2129 };"; 2130 $SOURCE2 .= " 2131 int AddedMiddleFieldAndSize::method(AddedMiddleFieldAndSize param) { return 0; }"; 2132 2133 # Added_Field (padding) 2134 $HEADER1 .= " 2135 struct $DECL_SPEC AddedMiddlePaddedField 2136 { 2137 int method(int param); 2138 short i; 2139 long j; 2140 double k; 2141 };"; 2142 $SOURCE1 .= " 2143 int AddedMiddlePaddedField::method(int param) { return 0; }"; 2144 2145 $HEADER2 .= " 2146 struct $DECL_SPEC AddedMiddlePaddedField 2147 { 2148 int method(int param); 2149 short i; 2150 short added_padded_field; 2151 long j; 2152 double k; 2153 };"; 2154 $SOURCE2 .= " 2155 int AddedMiddlePaddedField::method(int param) { return 0; }"; 2156 2157 # Added_Field (tail padding) 2158 $HEADER1 .= " 2159 struct $DECL_SPEC AddedTailField 2160 { 2161 int method(int param); 2162 int i1, i2, i3, i4, i5, i6, i7; 2163 short s; 2164 };"; 2165 $SOURCE1 .= " 2166 int AddedTailField::method(int param) { return 0; }"; 2167 2168 $HEADER2 .= " 2169 struct $DECL_SPEC AddedTailField 2170 { 2171 int method(int param); 2172 int i1, i2, i3, i4, i5, i6, i7; 2173 short s; 2174 short added_tail_field; 2175 };"; 2176 $SOURCE2 .= " 2177 int AddedTailField::method(int param) { return 0; }"; 2178 2179 # Test Alignment 2180 $HEADER1 .= " 2181 struct $DECL_SPEC TestAlignment 2182 { 2183 int method(int param); 2184 short s:9; 2185 short j:9; 2186 char c; 2187 short t:9; 2188 short u:9; 2189 char d; 2190 };"; 2191 $SOURCE1 .= " 2192 int TestAlignment::method(int param) { return 0; }"; 2193 2194 $HEADER2 .= " 2195 struct $DECL_SPEC TestAlignment 2196 { 2197 int method(int param); 2198 short s:9; 2199 short j:9; 2200 char c; 2201 short t:9; 2202 short u:9; 2203 char d; 2204 };"; 2205 $SOURCE2 .= " 2206 int TestAlignment::method(int param) { return 0; }"; 2207 2208 # Renamed_Field 2209 $HEADER1 .= " 2210 struct $DECL_SPEC RenamedField 2211 { 2212 int method(RenamedField param); 2213 long i; 2214 long j; 2215 double k; 2216 RenamedField* p; 2217 };"; 2218 $SOURCE1 .= " 2219 int RenamedField::method(RenamedField param) { return 0; }"; 2220 2221 $HEADER2 .= " 2222 struct $DECL_SPEC RenamedField 2223 { 2224 int method(RenamedField param); 2225 long renamed_member; 2226 long j; 2227 double k; 2228 RenamedField* p; 2229 };"; 2230 $SOURCE2 .= " 2231 int RenamedField::method(RenamedField param) { return 0; }"; 2232 2233 # Removed_Field_And_Size 2234 $HEADER1 .= " 2235 struct $DECL_SPEC RemovedFieldAndSize 2236 { 2237 int method(RemovedFieldAndSize param); 2238 double i, j, k; 2239 RemovedFieldAndSize* p; 2240 int removed_member1; 2241 long removed_member2; 2242 };"; 2243 $SOURCE1 .= " 2244 int RemovedFieldAndSize::method(RemovedFieldAndSize param) { return 0; }"; 2245 2246 $HEADER2 .= " 2247 struct $DECL_SPEC RemovedFieldAndSize 2248 { 2249 int method(RemovedFieldAndSize param); 2250 double i, j, k; 2251 RemovedFieldAndSize* p; 2252 };"; 2253 $SOURCE2 .= " 2254 int RemovedFieldAndSize::method(RemovedFieldAndSize param) { return 0; }"; 2255 2256 # Field Position 2257 $HEADER1 .= " 2258 struct $DECL_SPEC MovedField 2259 { 2260 int method(int param); 2261 double i; 2262 int j; 2263 };"; 2264 $SOURCE1 .= " 2265 int MovedField::method(int param) { return 0; }"; 2266 2267 $HEADER2 .= " 2268 struct $DECL_SPEC MovedField 2269 { 2270 int method(int param); 2271 int j; 2272 double i; 2273 };"; 2274 $SOURCE2 .= " 2275 int MovedField::method(int param) { return 0; }"; 2276 2277 # Removed_Middle_Field_And_Size 2278 $HEADER1 .= " 2279 struct $DECL_SPEC RemovedMiddleFieldAndSize 2280 { 2281 int method(RemovedMiddleFieldAndSize param); 2282 int i; 2283 int removed_middle_member; 2284 long j; 2285 double k; 2286 RemovedMiddleFieldAndSize* p; 2287 };"; 2288 $SOURCE1 .= " 2289 int RemovedMiddleFieldAndSize::method(RemovedMiddleFieldAndSize param) { return 0; }"; 2290 2291 $HEADER2 .= " 2292 struct $DECL_SPEC RemovedMiddleFieldAndSize 2293 { 2294 int method(RemovedMiddleFieldAndSize param); 2295 int i; 2296 long j; 2297 double k; 2298 RemovedMiddleFieldAndSize* p; 2299 };"; 2300 $SOURCE2 .= " 2301 int RemovedMiddleFieldAndSize::method(RemovedMiddleFieldAndSize param) { return 0; }"; 2302 2303 # Enum_Member_Value 2304 $HEADER1 .= " 2305 enum EnumMemberValue 2306 { 2307 MEMBER_1=1, 2308 MEMBER_2=2 2309 };"; 2310 $HEADER1 .= " 2311 $DECL_SPEC int enumMemberValueChange(enum EnumMemberValue param);"; 2312 $SOURCE1 .= " 2313 int enumMemberValueChange(enum EnumMemberValue param) { return 0; }"; 2314 2315 $HEADER2 .= " 2316 enum EnumMemberValue 2317 { 2318 MEMBER_1=2, 2319 MEMBER_2=1 2320 };"; 2321 $HEADER2 .= " 2322 $DECL_SPEC int enumMemberValueChange(enum EnumMemberValue param);"; 2323 $SOURCE2 .= " 2324 int enumMemberValueChange(enum EnumMemberValue param) { return 0; }"; 2325 2326 # Enum_Member_Name 2327 $HEADER1 .= " 2328 enum EnumMemberRename 2329 { 2330 BRANCH_1=1, 2331 BRANCH_2=2 2332 };"; 2333 $HEADER1 .= " 2334 $DECL_SPEC int enumMemberRename(enum EnumMemberRename param);"; 2335 $SOURCE1 .= " 2336 int enumMemberRename(enum EnumMemberRename param) { return 0; }"; 2337 2338 $HEADER2 .= " 2339 enum EnumMemberRename 2340 { 2341 BRANCH_FIRST=1, 2342 BRANCH_SECOND=2 2343 };"; 2344 $HEADER2 .= " 2345 $DECL_SPEC int enumMemberRename(enum EnumMemberRename param);"; 2346 $SOURCE2 .= " 2347 int enumMemberRename(enum EnumMemberRename param) { return 0; }"; 2348 2349 # Field_Type_And_Size 2350 $HEADER1 .= " 2351 struct $DECL_SPEC FieldTypeAndSize 2352 { 2353 int method(FieldTypeAndSize param); 2354 int i; 2355 long j; 2356 double k; 2357 FieldTypeAndSize* p; 2358 };"; 2359 $SOURCE1 .= " 2360 int FieldTypeAndSize::method(FieldTypeAndSize param) { return 0; }"; 2361 2362 $HEADER2 .= " 2363 struct $DECL_SPEC FieldTypeAndSize 2364 { 2365 int method(FieldTypeAndSize param); 2366 long long i; 2367 long j; 2368 double k; 2369 FieldTypeAndSize* p; 2370 };"; 2371 $SOURCE2 .= " 2372 int FieldTypeAndSize::method(FieldTypeAndSize param) { return 0; }"; 2373 2374 # Member_Type 2375 $HEADER1 .= " 2376 struct $DECL_SPEC MemberType 2377 { 2378 int method(MemberType param); 2379 int i; 2380 long j; 2381 double k; 2382 MemberType* p; 2383 };"; 2384 $SOURCE1 .= " 2385 int MemberType::method(MemberType param) { return 0; }"; 2386 2387 $HEADER2 .= " 2388 struct $DECL_SPEC MemberType 2389 { 2390 int method(MemberType param); 2391 float i; 2392 long j; 2393 double k; 2394 MemberType* p; 2395 };"; 2396 $SOURCE2 .= " 2397 int MemberType::method(MemberType param) { return 0; }"; 2398 2399 # Field_BaseType 2400 $HEADER1 .= " 2401 struct $DECL_SPEC FieldBaseType 2402 { 2403 int method(FieldBaseType param); 2404 int *i; 2405 long j; 2406 double k; 2407 FieldBaseType* p; 2408 };"; 2409 $SOURCE1 .= " 2410 int FieldBaseType::method(FieldBaseType param) { return 0; }"; 2411 2412 $HEADER2 .= " 2413 struct $DECL_SPEC FieldBaseType 2414 { 2415 int method(FieldBaseType param); 2416 long long *i; 2417 long j; 2418 double k; 2419 FieldBaseType* p; 2420 };"; 2421 $SOURCE2 .= " 2422 int FieldBaseType::method(FieldBaseType param) { return 0; }"; 2423 2424 # Field_PointerLevel_Increased (and size) 2425 $HEADER1 .= " 2426 struct $DECL_SPEC FieldPointerLevelAndSize 2427 { 2428 int method(FieldPointerLevelAndSize param); 2429 long long i; 2430 long j; 2431 double k; 2432 FieldPointerLevelAndSize* p; 2433 };"; 2434 $SOURCE1 .= " 2435 int FieldPointerLevelAndSize::method(FieldPointerLevelAndSize param) { return 0; }"; 2436 2437 $HEADER2 .= " 2438 struct $DECL_SPEC FieldPointerLevelAndSize 2439 { 2440 int method(FieldPointerLevelAndSize param); 2441 long long *i; 2442 long j; 2443 double k; 2444 FieldPointerLevelAndSize* p; 2445 };"; 2446 $SOURCE2 .= " 2447 int FieldPointerLevelAndSize::method(FieldPointerLevelAndSize param) { return 0; }"; 2448 2449 # Field_PointerLevel 2450 $HEADER1 .= " 2451 struct $DECL_SPEC FieldPointerLevel 2452 { 2453 int method(FieldPointerLevel param); 2454 int **i; 2455 long j; 2456 double k; 2457 FieldPointerLevel* p; 2458 };"; 2459 $SOURCE1 .= " 2460 int FieldPointerLevel::method(FieldPointerLevel param) { return 0; }"; 2461 2462 $HEADER2 .= " 2463 struct $DECL_SPEC FieldPointerLevel 2464 { 2465 int method(FieldPointerLevel param); 2466 int *i; 2467 long j; 2468 double k; 2469 FieldPointerLevel* p; 2470 };"; 2471 $SOURCE2 .= " 2472 int FieldPointerLevel::method(FieldPointerLevel param) { return 0; }"; 2473 2474 # Added_Interface (method) 2475 $HEADER1 .= " 2476 struct $DECL_SPEC AddedInterface 2477 { 2478 int method(AddedInterface param); 2479 int i; 2480 long j; 2481 double k; 2482 AddedInterface* p; 2483 };"; 2484 $SOURCE1 .= " 2485 int AddedInterface::method(AddedInterface param) { return 0; }"; 2486 2487 $HEADER2 .= " 2488 struct $DECL_SPEC AddedInterface 2489 { 2490 int method(AddedInterface param); 2491 int added_func(AddedInterface param); 2492 int i; 2493 long j; 2494 double k; 2495 AddedInterface* p; 2496 };"; 2497 $SOURCE2 .= " 2498 int AddedInterface::method(AddedInterface param) { return 0; }"; 2499 $SOURCE2 .= " 2500 int AddedInterface::added_func(AddedInterface param) { return 0; }"; 2501 2502 # Added_Interface (function) 2503 $HEADER2 .= " 2504 $DECL_SPEC int addedFunc2(void *** param);"; 2505 $SOURCE2 .= " 2506 int addedFunc2(void *** param) { return 0; }"; 2507 2508 # Added_Interface (global variable) 2509 $HEADER1 .= " 2510 struct $DECL_SPEC AddedVariable 2511 { 2512 int method(AddedVariable param); 2513 int i1, i2; 2514 long j; 2515 double k; 2516 AddedVariable* p; 2517 };"; 2518 $SOURCE1 .= " 2519 int AddedVariable::method(AddedVariable param) { 2520 return i1; 2521 }"; 2522 2523 $HEADER2 .= " 2524 struct $DECL_SPEC AddedVariable 2525 { 2526 int method(AddedVariable param); 2527 static int i1; 2528 static int i2; 2529 long j; 2530 double k; 2531 AddedVariable* p; 2532 };"; 2533 $SOURCE2 .= " 2534 int AddedVariable::method(AddedVariable param) { return AddedVariable::i1; }"; 2535 $SOURCE2 .= " 2536 int AddedVariable::i1=0;"; 2537 $SOURCE2 .= " 2538 int AddedVariable::i2=0;"; 2539 2540 # Removed_Interface (method) 2541 $HEADER1 .= " 2542 struct $DECL_SPEC RemovedInterface 2543 { 2544 int method(RemovedInterface param); 2545 int removed_func(RemovedInterface param); 2546 int i; 2547 long j; 2548 double k; 2549 RemovedInterface* p; 2550 };"; 2551 $SOURCE1 .= " 2552 int RemovedInterface::method(RemovedInterface param) { return 0; }"; 2553 $SOURCE1 .= " 2554 int RemovedInterface::removed_func(RemovedInterface param) { return 0; }"; 2555 2556 $HEADER2 .= " 2557 struct $DECL_SPEC RemovedInterface 2558 { 2559 int method(RemovedInterface param); 2560 int i; 2561 long j; 2562 double k; 2563 RemovedInterface* p; 2564 };"; 2565 $SOURCE2 .= " 2566 int RemovedInterface::method(RemovedInterface param) { return 0; }"; 2567 2568 # Removed_Interface (function) 2569 $HEADER1 .= " 2570 $DECL_SPEC int removedFunc2(void *** param);"; 2571 $SOURCE1 .= " 2572 int removedFunc2(void *** param) { return 0; }"; 2573 2574 # Method_Became_Static 2575 $HEADER1 .= " 2576 struct $DECL_SPEC MethodBecameStatic 2577 { 2578 MethodBecameStatic becameStatic(MethodBecameStatic param); 2579 int **i; 2580 long j; 2581 double k; 2582 MethodBecameStatic* p; 2583 };"; 2584 $SOURCE1 .= " 2585 MethodBecameStatic MethodBecameStatic::becameStatic(MethodBecameStatic param) { return param; }"; 2586 2587 $HEADER2 .= " 2588 struct $DECL_SPEC MethodBecameStatic 2589 { 2590 static MethodBecameStatic becameStatic(MethodBecameStatic param); 2591 int **i; 2592 long j; 2593 double k; 2594 MethodBecameStatic* p; 2595 };"; 2596 $SOURCE2 .= " 2597 MethodBecameStatic MethodBecameStatic::becameStatic(MethodBecameStatic param) { return param; }"; 2598 2599 # Method_Became_Non_Static 2600 $HEADER1 .= " 2601 struct $DECL_SPEC MethodBecameNonStatic 2602 { 2603 static MethodBecameNonStatic becameNonStatic(MethodBecameNonStatic param); 2604 int **i; 2605 long j; 2606 double k; 2607 MethodBecameNonStatic* p; 2608 };"; 2609 $SOURCE1 .= " 2610 MethodBecameNonStatic MethodBecameNonStatic::becameNonStatic(MethodBecameNonStatic param) { return param; }"; 2611 2612 $HEADER2 .= " 2613 struct $DECL_SPEC MethodBecameNonStatic 2614 { 2615 MethodBecameNonStatic becameNonStatic(MethodBecameNonStatic param); 2616 int **i; 2617 long j; 2618 double k; 2619 MethodBecameNonStatic* p; 2620 };"; 2621 $SOURCE2 .= " 2622 MethodBecameNonStatic MethodBecameNonStatic::becameNonStatic(MethodBecameNonStatic param) { return param; }"; 2623 2624 # Parameter_Type_And_Size 2625 $HEADER1 .= " 2626 $DECL_SPEC int funcParameterTypeAndSize(int param, int other_param);"; 2627 $SOURCE1 .= " 2628 int funcParameterTypeAndSize(int param, int other_param) { return other_param; }"; 2629 2630 $HEADER2 .= " 2631 $DECL_SPEC int funcParameterTypeAndSize(long long param, int other_param);"; 2632 $SOURCE2 .= " 2633 int funcParameterTypeAndSize(long long param, int other_param) { return other_param; }"; 2634 2635 # Parameter_Type 2636 $HEADER1 .= " 2637 $DECL_SPEC int funcParameterType(int param, int other_param);"; 2638 $SOURCE1 .= " 2639 int funcParameterType(int param, int other_param) { return other_param; }"; 2640 2641 $HEADER2 .= " 2642 $DECL_SPEC int funcParameterType(float param, int other_param);"; 2643 $SOURCE2 .= " 2644 int funcParameterType(float param, int other_param) { return other_param; }"; 2645 2646 # Parameter_BaseType 2647 $HEADER1 .= " 2648 $DECL_SPEC int funcParameterBaseType(int *param);"; 2649 $SOURCE1 .= " 2650 int funcParameterBaseType(int *param) { return sizeof(*param); }"; 2651 2652 $HEADER2 .= " 2653 $DECL_SPEC int funcParameterBaseType(long long *param);"; 2654 $SOURCE2 .= " 2655 int funcParameterBaseType(long long *param) { return sizeof(*param); }"; 2656 2657 # Parameter_PointerLevel 2658 $HEADER1 .= " 2659 $DECL_SPEC long long funcParameterPointerLevelAndSize(long long param);"; 2660 $SOURCE1 .= " 2661 long long funcParameterPointerLevelAndSize(long long param) { return param; }"; 2662 2663 $HEADER2 .= " 2664 $DECL_SPEC long long funcParameterPointerLevelAndSize(long long *param);"; 2665 $SOURCE2 .= " 2666 long long funcParameterPointerLevelAndSize(long long *param) { return param[5]; }"; 2667 2668 # Parameter_PointerLevel 2669 $HEADER1 .= " 2670 $DECL_SPEC int funcParameterPointerLevel(int *param);"; 2671 $SOURCE1 .= " 2672 int funcParameterPointerLevel(int *param) { return param[5]; }"; 2673 2674 $HEADER2 .= " 2675 $DECL_SPEC int funcParameterPointerLevel(int **param);"; 2676 $SOURCE2 .= " 2677 int funcParameterPointerLevel(int **param) { return param[5][5]; }"; 2678 2679 # Return_Type_And_Size 2680 $HEADER1 .= " 2681 $DECL_SPEC int funcReturnTypeAndSize(int param);"; 2682 $SOURCE1 .= " 2683 int funcReturnTypeAndSize(int param) { return 0; }"; 2684 2685 $HEADER2 .= " 2686 $DECL_SPEC long long funcReturnTypeAndSize(int param);"; 2687 $SOURCE2 .= " 2688 long long funcReturnTypeAndSize(int param) { return 0; }"; 2689 2690 # Return_Type 2691 $HEADER1 .= " 2692 $DECL_SPEC int funcReturnType(int param);"; 2693 $SOURCE1 .= " 2694 int funcReturnType(int param) { return 0; }"; 2695 2696 $HEADER2 .= " 2697 $DECL_SPEC float funcReturnType(int param);"; 2698 $SOURCE2 .= " 2699 float funcReturnType(int param) { return 0.7; }"; 2700 2701 # Return_Type_Became_Void ("int" to "void") 2702 $HEADER1 .= " 2703 $DECL_SPEC int funcReturnTypeBecameVoid(int param);"; 2704 $SOURCE1 .= " 2705 int funcReturnTypeBecameVoid(int param) { return 0; }"; 2706 2707 $HEADER2 .= " 2708 $DECL_SPEC void funcReturnTypeBecameVoid(int param);"; 2709 $SOURCE2 .= " 2710 void funcReturnTypeBecameVoid(int param) { return; }"; 2711 2712 # Return_BaseType 2713 $HEADER1 .= " 2714 $DECL_SPEC int* funcReturnBaseType(int param);"; 2715 $SOURCE1 .= " 2716 int* funcReturnBaseType(int param) { 2717 int *x = new int[10]; 2718 return x; 2719 }"; 2720 2721 $HEADER2 .= " 2722 $DECL_SPEC long long* funcReturnBaseType(int param);"; 2723 $SOURCE2 .= " 2724 long long* funcReturnBaseType(int param) { 2725 long long *x = new long long[10]; 2726 return x; 2727 }"; 2728 2729 # Return_PointerLevel 2730 $HEADER1 .= " 2731 $DECL_SPEC long long funcReturnPointerLevelAndSize(int param);"; 2732 $SOURCE1 .= " 2733 long long funcReturnPointerLevelAndSize(int param) { return 0; }"; 2734 2735 $HEADER2 .= " 2736 $DECL_SPEC long long* funcReturnPointerLevelAndSize(int param);"; 2737 $SOURCE2 .= " 2738 long long* funcReturnPointerLevelAndSize(int param) { return new long long[10]; }"; 2739 2740 # Return_PointerLevel 2741 $HEADER1 .= " 2742 $DECL_SPEC int* funcReturnPointerLevel(int param);"; 2743 $SOURCE1 .= " 2744 int* funcReturnPointerLevel(int param) { return new int[10]; }"; 2745 2746 $HEADER2 .= " 2747 $DECL_SPEC int** funcReturnPointerLevel(int param);"; 2748 $SOURCE2 .= " 2749 int** funcReturnPointerLevel(int param) { return new int*[10]; }"; 2750 2751 # Size (anon type) 2752 $HEADER1 .= " 2753 typedef struct { 2754 int i; 2755 long j; 2756 double k; 2757 } AnonTypedef; 2758 $DECL_SPEC int funcAnonTypedef(AnonTypedef param);"; 2759 $SOURCE1 .= " 2760 int funcAnonTypedef(AnonTypedef param) { return 0; }"; 2761 2762 $HEADER2 .= " 2763 typedef struct { 2764 int i; 2765 long j; 2766 double k; 2767 union { 2768 int dummy[256]; 2769 struct { 2770 char q_skiptable[256]; 2771 const char *p; 2772 int l; 2773 } p; 2774 }; 2775 } AnonTypedef; 2776 $DECL_SPEC int funcAnonTypedef(AnonTypedef param);"; 2777 $SOURCE2 .= " 2778 int funcAnonTypedef(AnonTypedef param) { return 0; }"; 2779 2780 # Added_Field (safe: opaque) 2781 $HEADER1 .= " 2782 struct $DECL_SPEC OpaqueType 2783 { 2784 public: 2785 OpaqueType method(OpaqueType param); 2786 int i; 2787 long j; 2788 double k; 2789 OpaqueType* p; 2790 };"; 2791 $SOURCE1 .= " 2792 OpaqueType OpaqueType::method(OpaqueType param) { return param; }"; 2793 2794 $HEADER2 .= " 2795 struct $DECL_SPEC OpaqueType 2796 { 2797 public: 2798 OpaqueType method(OpaqueType param); 2799 int i; 2800 long j; 2801 double k; 2802 OpaqueType* p; 2803 int added_member; 2804 };"; 2805 $SOURCE2 .= " 2806 OpaqueType OpaqueType::method(OpaqueType param) { return param; }"; 2807 2808 # Added_Field (safe: internal) 2809 $HEADER1 .= " 2810 struct $DECL_SPEC InternalType { 2811 InternalType method(InternalType param); 2812 int i; 2813 long j; 2814 double k; 2815 InternalType* p; 2816 };"; 2817 $SOURCE1 .= " 2818 InternalType InternalType::method(InternalType param) { return param; }"; 2819 2820 $HEADER2 .= " 2821 struct $DECL_SPEC InternalType { 2822 InternalType method(InternalType param); 2823 int i; 2824 long j; 2825 double k; 2826 InternalType* p; 2827 int added_member; 2828 };"; 2829 $SOURCE2 .= " 2830 InternalType InternalType::method(InternalType param) { return param; }"; 2831 2832 # Size (unnamed struct/union fields within structs/unions) 2833 $HEADER1 .= " 2834 typedef struct { 2835 int a; 2836 struct { 2837 int u1; 2838 float u2; 2839 }; 2840 int d; 2841 } UnnamedTypeSize; 2842 $DECL_SPEC int unnamedTypeSize(UnnamedTypeSize param);"; 2843 $SOURCE1 .= " 2844 int unnamedTypeSize(UnnamedTypeSize param) { return 0; }"; 2845 2846 $HEADER2 .= " 2847 typedef struct { 2848 int a; 2849 struct { 2850 long double u1; 2851 float u2; 2852 }; 2853 int d; 2854 } UnnamedTypeSize; 2855 $DECL_SPEC int unnamedTypeSize(UnnamedTypeSize param);"; 2856 $SOURCE2 .= " 2857 int unnamedTypeSize(UnnamedTypeSize param) { return 0; }"; 2858 2859 # Changed_Constant 2860 $HEADER1 .= " 2861 #define PUBLIC_CONSTANT \"old_value\""; 2862 $HEADER2 .= " 2863 #define PUBLIC_CONSTANT \"new_value\""; 2864 2865 $HEADER1 .= " 2866 #define PUBLIC_VERSION \"1.2 (3.4)\""; 2867 $HEADER2 .= " 2868 #define PUBLIC_VERSION \"1.2 (3.5)\""; 2869 2870 $HEADER1 .= " 2871 #define PRIVATE_CONSTANT \"old_value\" 2872 #undef PRIVATE_CONSTANT"; 2873 $HEADER2 .= " 2874 #define PRIVATE_CONSTANT \"new_value\" 2875 #undef PRIVATE_CONSTANT"; 2876 2877 # Added_Field (union) 2878 $HEADER1 .= " 2879 union UnionAddedField { 2880 int a; 2881 struct { 2882 int b; 2883 float c; 2884 }; 2885 int d; 2886 }; 2887 $DECL_SPEC int unionAddedField(UnionAddedField param);"; 2888 $SOURCE1 .= " 2889 int unionAddedField(UnionAddedField param) { return 0; }"; 2890 2891 $HEADER2 .= " 2892 union UnionAddedField { 2893 int a; 2894 struct { 2895 long double x, y; 2896 } new_field; 2897 struct { 2898 int b; 2899 float c; 2900 }; 2901 int d; 2902 }; 2903 $DECL_SPEC int unionAddedField(UnionAddedField param);"; 2904 $SOURCE2 .= " 2905 int unionAddedField(UnionAddedField param) { return 0; }"; 2906 2907 # Removed_Field (union) 2908 $HEADER1 .= " 2909 union UnionRemovedField { 2910 int a; 2911 struct { 2912 long double x, y; 2913 } removed_field; 2914 struct { 2915 int b; 2916 float c; 2917 }; 2918 int d; 2919 }; 2920 $DECL_SPEC int unionRemovedField(UnionRemovedField param);"; 2921 $SOURCE1 .= " 2922 int unionRemovedField(UnionRemovedField param) { return 0; }"; 2923 2924 $HEADER2 .= " 2925 union UnionRemovedField { 2926 int a; 2927 struct { 2928 int b; 2929 float c; 2930 }; 2931 int d; 2932 }; 2933 $DECL_SPEC int unionRemovedField(UnionRemovedField param);"; 2934 $SOURCE2 .= " 2935 int unionRemovedField(UnionRemovedField param) { return 0; }"; 2936 2937 # Added (typedef change) 2938 $HEADER1 .= " 2939 typedef float TYPEDEF_TYPE; 2940 $DECL_SPEC int parameterTypedefChange(TYPEDEF_TYPE param);"; 2941 $SOURCE1 .= " 2942 int parameterTypedefChange(TYPEDEF_TYPE param) { return 1; }"; 2943 2944 $HEADER2 .= " 2945 typedef int TYPEDEF_TYPE; 2946 $DECL_SPEC int parameterTypedefChange(TYPEDEF_TYPE param);"; 2947 $SOURCE2 .= " 2948 int parameterTypedefChange(TYPEDEF_TYPE param) { return 1; }"; 2949 2950 # Parameter_Default_Value_Changed (safe) 2951 # Converted from void* to const char* 2952 $HEADER1 .= " 2953 $DECL_SPEC int paramDefaultValue_Converted(const char* arg = 0); "; 2954 $SOURCE1 .= " 2955 int paramDefaultValue_Converted(const char* arg) { return 0; }"; 2956 2957 $HEADER2 .= " 2958 $DECL_SPEC int paramDefaultValue_Converted(const char* arg = (const char*)((void*) 0)); "; 2959 $SOURCE2 .= " 2960 int paramDefaultValue_Converted(const char* arg) { return 0; }"; 2961 2962 # Parameter_Default_Value_Changed 2963 # Integer 2964 $HEADER1 .= " 2965 $DECL_SPEC int paramDefaultValueChanged_Integer(int param = 0xf00f); "; 2966 $SOURCE1 .= " 2967 int paramDefaultValueChanged_Integer(int param) { return param; }"; 2968 2969 $HEADER2 .= " 2970 $DECL_SPEC int paramDefaultValueChanged_Integer(int param = 0xf00b); "; 2971 $SOURCE2 .= " 2972 int paramDefaultValueChanged_Integer(int param) { return param; }"; 2973 2974 # Parameter_Default_Value_Changed 2975 # String 2976 $HEADER1 .= " 2977 $DECL_SPEC int paramDefaultValueChanged_String(char const* param = \" str 1 \"); "; 2978 $SOURCE1 .= " 2979 int paramDefaultValueChanged_String(char const* param) { return 0; }"; 2980 2981 $HEADER2 .= " 2982 $DECL_SPEC int paramDefaultValueChanged_String(char const* param = \" str 2 \"); "; 2983 $SOURCE2 .= " 2984 int paramDefaultValueChanged_String(char const* param) { return 0; }"; 2985 2986 # Parameter_Default_Value_Changed 2987 # Character 2988 $HEADER1 .= " 2989 $DECL_SPEC int paramDefaultValueChanged_Char(char param = \'A\'); "; 2990 $SOURCE1 .= " 2991 int paramDefaultValueChanged_Char(char param) { return 0; }"; 2992 2993 $HEADER2 .= " 2994 $DECL_SPEC int paramDefaultValueChanged_Char(char param = \'B\'); "; 2995 $SOURCE2 .= " 2996 int paramDefaultValueChanged_Char(char param) { return 0; }"; 2997 2998 # Parameter_Default_Value_Changed 2999 # Bool 3000 $HEADER1 .= " 3001 $DECL_SPEC int paramDefaultValueChanged_Bool(bool param = true); "; 3002 $SOURCE1 .= " 3003 int paramDefaultValueChanged_Bool(bool param) { return 0; }"; 3004 3005 $HEADER2 .= " 3006 $DECL_SPEC int paramDefaultValueChanged_Bool(bool param = false); "; 3007 $SOURCE2 .= " 3008 int paramDefaultValueChanged_Bool(bool param) { return 0; }"; 3009 3010 # Parameter_Default_Value_Removed 3011 $HEADER1 .= " 3012 $DECL_SPEC int parameterDefaultValueRemoved(int param = 15); 3013 "; 3014 $SOURCE1 .= " 3015 int parameterDefaultValueRemoved(int param) { return param; }"; 3016 3017 $HEADER2 .= " 3018 $DECL_SPEC int parameterDefaultValueRemoved(int param);"; 3019 $SOURCE2 .= " 3020 int parameterDefaultValueRemoved(int param) { return param; }"; 3021 3022 # Parameter_Default_Value_Added 3023 $HEADER1 .= " 3024 $DECL_SPEC int parameterDefaultValueAdded(int param); 3025 "; 3026 $SOURCE1 .= " 3027 int parameterDefaultValueAdded(int param) { return param; }"; 3028 3029 $HEADER2 .= " 3030 $DECL_SPEC int parameterDefaultValueAdded(int param = 15);"; 3031 $SOURCE2 .= " 3032 int parameterDefaultValueAdded(int param) { return param; }"; 3033 3034 # Field_Type (typedefs in member type) 3035 $HEADER1 .= " 3036 typedef float TYPEDEF_TYPE_2; 3037 struct $DECL_SPEC FieldTypedefChange{ 3038 public: 3039 TYPEDEF_TYPE_2 m; 3040 TYPEDEF_TYPE_2 n; 3041 }; 3042 $DECL_SPEC int fieldTypedefChange(FieldTypedefChange param);"; 3043 $SOURCE1 .= " 3044 int fieldTypedefChange(FieldTypedefChange param) { return 1; }"; 3045 3046 $HEADER2 .= " 3047 typedef int TYPEDEF_TYPE_2; 3048 struct $DECL_SPEC FieldTypedefChange{ 3049 public: 3050 TYPEDEF_TYPE_2 m; 3051 TYPEDEF_TYPE_2 n; 3052 }; 3053 $DECL_SPEC int fieldTypedefChange(FieldTypedefChange param);"; 3054 $SOURCE2 .= " 3055 int fieldTypedefChange(FieldTypedefChange param) { return 1; }"; 3056 3057 # Callback (testCallback symbol should be affected 3058 # instead of callback1 and callback2) 3059 $HEADER1 .= " 3060 class $DECL_SPEC Callback { 3061 public: 3062 virtual int callback1(int x, int y)=0; 3063 virtual int callback2(int x, int y)=0; 3064 }; 3065 $DECL_SPEC int testCallback(Callback* p);"; 3066 $SOURCE1 .= " 3067 int testCallback(Callback* p) { 3068 p->callback2(1, 2); 3069 return 0; 3070 }"; 3071 3072 $HEADER2 .= " 3073 class $DECL_SPEC Callback { 3074 public: 3075 virtual int callback1(int x, int y)=0; 3076 virtual int added_callback(int x, int y)=0; 3077 virtual int callback2(int x, int y)=0; 3078 }; 3079 $DECL_SPEC int testCallback(Callback* p);"; 3080 $SOURCE2 .= " 3081 int testCallback(Callback* p) { 3082 p->callback2(1, 2); 3083 return 0; 3084 }"; 3085 3086 # End namespace 3087 $HEADER1 .= "\n}\n"; 3088 $HEADER2 .= "\n}\n"; 3089 $SOURCE1 .= "\n}\n"; 3090 $SOURCE2 .= "\n}\n"; 3091 3092 runTests("libsample_cpp", "C++", $HEADER1, $SOURCE1, $HEADER2, $SOURCE2, "TestNS::OpaqueType", "_ZN6TestNS12InternalType6methodES0_"); 3093} 3094 3095sub testC() 3096{ 3097 printMsg("INFO", "\nVerifying detectable C library changes"); 3098 my ($HEADER1, $SOURCE1, $HEADER2, $SOURCE2) = (); 3099 3100 my $DECL_SPEC = ""; 3101 my $EXTERN = ""; 3102 3103 if($In::Opt{"OS"} eq "windows") 3104 { 3105 $DECL_SPEC = "__declspec( dllexport )"; 3106 $EXTERN = "extern "; # add "extern" for CL compiler 3107 } 3108 3109 # Array size 3110 $HEADER1 .= " 3111 $DECL_SPEC int arraySize(int p[10]);"; 3112 $SOURCE1 .= " 3113 int arraySize(int p[10]) { return 0; }"; 3114 3115 $HEADER2 .= " 3116 $DECL_SPEC int arraySize(int p[15]);"; 3117 $SOURCE2 .= " 3118 int arraySize(int p[15]) { return 0; }"; 3119 3120 # Struct to union 3121 $HEADER1 .= " 3122 typedef struct StructToUnion { 3123 unsigned char A[64]; 3124 } StructToUnion; 3125 3126 $DECL_SPEC int structToUnion(StructToUnion *p);"; 3127 $SOURCE1 .= " 3128 int structToUnion(StructToUnion *p) { return 0; }"; 3129 3130 $HEADER2 .= " 3131 typedef union StructToUnion { 3132 unsigned char A[64]; 3133 void *p; 3134 } StructToUnion; 3135 3136 $DECL_SPEC int structToUnion(StructToUnion *p);"; 3137 $SOURCE2 .= " 3138 int structToUnion(StructToUnion *p) { return 0; }"; 3139 3140 # Typedef to function 3141 $HEADER1 .= " 3142 typedef int(TypedefToFunction)(int pX); 3143 3144 $DECL_SPEC int typedefToFunction(TypedefToFunction* p);"; 3145 $SOURCE1 .= " 3146 int typedefToFunction(TypedefToFunction* p) { return 0; }"; 3147 3148 $HEADER2 .= " 3149 typedef int(TypedefToFunction)(int pX, int pY); 3150 3151 $DECL_SPEC int typedefToFunction(TypedefToFunction* p);"; 3152 $SOURCE2 .= " 3153 int typedefToFunction(TypedefToFunction* p) { return 0; }"; 3154 3155 # Used_Reserved 3156 $HEADER1 .= " 3157 typedef struct { 3158 int f; 3159 void* reserved0; 3160 void* reserved1; 3161 } UsedReserved; 3162 3163 $DECL_SPEC int usedReserved(UsedReserved p);"; 3164 $SOURCE1 .= " 3165 int usedReserved(UsedReserved p) { return 0; }"; 3166 3167 $HEADER2 .= " 3168 typedef struct { 3169 int f; 3170 void* f0; 3171 void* f1; 3172 } UsedReserved; 3173 3174 $DECL_SPEC int usedReserved(UsedReserved p);"; 3175 $SOURCE2 .= " 3176 int usedReserved(UsedReserved p) { return 0; }"; 3177 3178 # Parameter_Type_And_Register 3179 $HEADER1 .= " 3180 typedef struct { 3181 int a[4]; 3182 } ARRAY; 3183 $DECL_SPEC void callConv5 (ARRAY i, int j);"; 3184 $SOURCE1 .= " 3185 void callConv5 (ARRAY i, int j) { }"; 3186 3187 $HEADER2 .= " 3188 typedef struct { 3189 int a[4]; 3190 } ARRAY; 3191 $DECL_SPEC void callConv5 (ARRAY i, double j);"; 3192 $SOURCE2 .= " 3193 void callConv5 (ARRAY i, double j) { }"; 3194 3195 # Parameter_Type_And_Register 3196 $HEADER1 .= " 3197 typedef union { 3198 int a; 3199 double b; 3200 } UNION; 3201 $DECL_SPEC void callConv4 (UNION i, int j);"; 3202 $SOURCE1 .= " 3203 void callConv4 (UNION i, int j) { }"; 3204 3205 $HEADER2 .= " 3206 typedef union { 3207 int a; 3208 double b; 3209 } UNION; 3210 $DECL_SPEC void callConv4 (UNION i, double j);"; 3211 $SOURCE2 .= " 3212 void callConv4 (UNION i, double j) { }"; 3213 3214 # Parameter_Type_And_Register 3215 $HEADER1 .= " 3216 typedef struct { 3217 long a:4; 3218 long b:16; 3219 } POD2; 3220 $DECL_SPEC void callConv3 (POD2 i, int j);"; 3221 $SOURCE1 .= " 3222 void callConv3 (POD2 i, int j) { }"; 3223 3224 $HEADER2 .= " 3225 typedef struct { 3226 long a:4; 3227 long b:16; 3228 } POD2; 3229 $DECL_SPEC void callConv3 (POD2 i, double j);"; 3230 $SOURCE2 .= " 3231 void callConv3 (POD2 i, double j) { }"; 3232 3233 # Parameter_Type_And_Register 3234 $HEADER1 .= " 3235 typedef struct { 3236 short s:9; 3237 int j:9; 3238 char c; 3239 short t:9; 3240 short u:9; 3241 char d; 3242 } POD; 3243 $DECL_SPEC void callConv2 (POD i, int j);"; 3244 $SOURCE1 .= " 3245 void callConv2 (POD i, int j) { }"; 3246 3247 $HEADER2 .= " 3248 typedef struct { 3249 short s:9; 3250 int j:9; 3251 char c; 3252 short t:9; 3253 short u:9; 3254 char d; 3255 } POD; 3256 $DECL_SPEC void callConv2 (POD i, double j);"; 3257 $SOURCE2 .= " 3258 void callConv2 (POD i, double j) { }"; 3259 3260 # Parameter_Type_And_Register 3261 $HEADER1 .= " 3262 typedef struct { 3263 int a, b; 3264 double d; 3265 } POD1; 3266 $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);"; 3267 $SOURCE1 .= " 3268 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) { }"; 3269 3270 $HEADER2 .= " 3271 typedef struct { 3272 int a, b; 3273 double d; 3274 } POD1; 3275 $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);"; 3276 $SOURCE2 .= " 3277 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) { }"; 3278 3279 # Parameter_Type (int to "int const") 3280 $HEADER1 .= " 3281 $DECL_SPEC void parameterBecameConstInt(int arg);"; 3282 $SOURCE1 .= " 3283 void parameterBecameConstInt(int arg) { }"; 3284 3285 $HEADER2 .= " 3286 $DECL_SPEC void parameterBecameConstInt(const int arg);"; 3287 $SOURCE2 .= " 3288 void parameterBecameConstInt(const int arg) { }"; 3289 3290 # Parameter_Type ("int const" to int) 3291 $HEADER1 .= " 3292 $DECL_SPEC void parameterBecameNonConstInt(const int arg);"; 3293 $SOURCE1 .= " 3294 void parameterBecameNonConstInt(const int arg) { }"; 3295 3296 $HEADER2 .= " 3297 $DECL_SPEC void parameterBecameNonConstInt(int arg);"; 3298 $SOURCE2 .= " 3299 void parameterBecameNonConstInt(int arg) { }"; 3300 3301 # Parameter_Became_Register 3302 $HEADER1 .= " 3303 $DECL_SPEC void parameterBecameRegister(int arg);"; 3304 $SOURCE1 .= " 3305 void parameterBecameRegister(int arg) { }"; 3306 3307 $HEADER2 .= " 3308 $DECL_SPEC void parameterBecameRegister(register int arg);"; 3309 $SOURCE2 .= " 3310 void parameterBecameRegister(register int arg) { }"; 3311 3312 # Return_Type_Became_Const 3313 $HEADER1 .= " 3314 $DECL_SPEC char* returnTypeBecameConst(int param);"; 3315 $SOURCE1 .= " 3316 char* returnTypeBecameConst(int param) { return (char*)malloc(256); }"; 3317 3318 $HEADER2 .= " 3319 $DECL_SPEC const char* returnTypeBecameConst(int param);"; 3320 $SOURCE2 .= " 3321 const char* returnTypeBecameConst(int param) { return \"abc\"; }"; 3322 3323 # Return_Type_Became_Const (2) 3324 $HEADER1 .= " 3325 $DECL_SPEC char* returnTypeBecameConst2(int param);"; 3326 $SOURCE1 .= " 3327 char* returnTypeBecameConst2(int param) { return (char*)malloc(256); }"; 3328 3329 $HEADER2 .= " 3330 $DECL_SPEC char*const returnTypeBecameConst2(int param);"; 3331 $SOURCE2 .= " 3332 char*const returnTypeBecameConst2(int param) { return (char*const)malloc(256); }"; 3333 3334 # Return_Type_Became_Const (3) 3335 $HEADER1 .= " 3336 $DECL_SPEC char* returnTypeBecameConst3(int param);"; 3337 $SOURCE1 .= " 3338 char* returnTypeBecameConst3(int param) { return (char*)malloc(256); }"; 3339 3340 $HEADER2 .= " 3341 $DECL_SPEC char const*const returnTypeBecameConst3(int param);"; 3342 $SOURCE2 .= " 3343 char const*const returnTypeBecameConst3(int param) { return (char const*const)malloc(256); }"; 3344 3345 # Return_Type_Became_Volatile 3346 $HEADER1 .= " 3347 $DECL_SPEC char* returnTypeBecameVolatile(int param);"; 3348 $SOURCE1 .= " 3349 char* returnTypeBecameVolatile(int param) { return (char*)malloc(256); }"; 3350 3351 $HEADER2 .= " 3352 $DECL_SPEC volatile char* returnTypeBecameVolatile(int param);"; 3353 $SOURCE2 .= " 3354 volatile char* returnTypeBecameVolatile(int param) { return \"abc\"; }"; 3355 3356 # Added_Enum_Member 3357 $HEADER1 .= " 3358 enum AddedEnumMember { 3359 OldMember 3360 }; 3361 $DECL_SPEC int addedEnumMember(enum AddedEnumMember param);"; 3362 $SOURCE1 .= " 3363 int addedEnumMember(enum AddedEnumMember param) { return 0; }"; 3364 3365 $HEADER2 .= " 3366 enum AddedEnumMember { 3367 OldMember, 3368 NewMember 3369 }; 3370 $DECL_SPEC int addedEnumMember(enum AddedEnumMember param);"; 3371 $SOURCE2 .= " 3372 int addedEnumMember(enum AddedEnumMember param) { return 0; }"; 3373 3374 # Parameter_Type (Array) 3375 $HEADER1 .= " 3376 $DECL_SPEC int arrayParameterType(int param[5]);"; 3377 $SOURCE1 .= " 3378 int arrayParameterType(int param[5]) { return 0; }"; 3379 3380 $HEADER2 .= " 3381 $DECL_SPEC int arrayParameterType(int param[7]);"; 3382 $SOURCE2 .= " 3383 int arrayParameterType(int param[7]) { return 0; }"; 3384 3385 # Field_Type 3386 $HEADER1 .= " 3387 struct ArrayFieldType 3388 { 3389 int f; 3390 int i[1]; 3391 }; 3392 $DECL_SPEC int arrayFieldType(struct ArrayFieldType param);"; 3393 $SOURCE1 .= " 3394 int arrayFieldType(struct ArrayFieldType param) { return param.i[0]; }"; 3395 3396 $HEADER2 .= " 3397 struct ArrayFieldType 3398 { 3399 int f; 3400 int i[]; 3401 }; 3402 $DECL_SPEC int arrayFieldType(struct ArrayFieldType param);"; 3403 $SOURCE2 .= " 3404 int arrayFieldType(struct ArrayFieldType param) { return param.i[0]; }"; 3405 3406 # Field_Type_And_Size (Array) 3407 $HEADER1 .= " 3408 struct ArrayFieldSize 3409 { 3410 int i[5]; 3411 }; 3412 $DECL_SPEC int arrayFieldSize(struct ArrayFieldSize param);"; 3413 $SOURCE1 .= " 3414 int arrayFieldSize(struct ArrayFieldSize param) { return 0; }"; 3415 3416 $HEADER2 .= " 3417 struct ArrayFieldSize 3418 { 3419 int i[7]; 3420 }; 3421 $DECL_SPEC int arrayFieldSize(struct ArrayFieldSize param);"; 3422 $SOURCE2 .= " 3423 int arrayFieldSize(struct ArrayFieldSize param) { return 0; }"; 3424 3425 # Parameter_Became_Non_VaList 3426 $HEADER1 .= " 3427 $DECL_SPEC int parameterNonVaList(int param, ...);"; 3428 $SOURCE1 .= " 3429 int parameterNonVaList(int param, ...) { return param; }"; 3430 3431 $HEADER2 .= " 3432 $DECL_SPEC int parameterNonVaList(int param1, int param2);"; 3433 $SOURCE2 .= " 3434 int parameterNonVaList(int param1, int param2) { return param1; }"; 3435 3436 # Parameter_Became_VaList 3437 $HEADER1 .= " 3438 $DECL_SPEC int parameterVaList(int param1, int param2);"; 3439 $SOURCE1 .= " 3440 int parameterVaList(int param1, int param2) { return param1; }"; 3441 3442 $HEADER2 .= " 3443 $DECL_SPEC int parameterVaList(int param, ...);"; 3444 $SOURCE2 .= " 3445 int parameterVaList(int param, ...) { return param; }"; 3446 3447 # Field_Type_And_Size 3448 $HEADER1 .= " 3449 struct FieldSizePadded 3450 { 3451 int i; 3452 char changed_field; 3453 // padding (3 bytes) 3454 int j; 3455 }; 3456 $DECL_SPEC int fieldSizePadded(struct FieldSizePadded param);"; 3457 $SOURCE1 .= " 3458 int fieldSizePadded(struct FieldSizePadded param) { return 0; }"; 3459 3460 $HEADER2 .= " 3461 struct FieldSizePadded 3462 { 3463 int i; 3464 int changed_field; 3465 int j; 3466 }; 3467 $DECL_SPEC int fieldSizePadded(struct FieldSizePadded param);"; 3468 $SOURCE2 .= " 3469 int fieldSizePadded(struct FieldSizePadded param) { return 0; }"; 3470 3471 # Parameter_Type_Format 3472 $HEADER1 .= " 3473 struct DType1 3474 { 3475 int i; 3476 double j[7]; 3477 }; 3478 $DECL_SPEC int parameterTypeFormat(struct DType1 param);"; 3479 $SOURCE1 .= " 3480 int parameterTypeFormat(struct DType1 param) { return 0; }"; 3481 3482 $HEADER2 .= " 3483 struct DType2 3484 { 3485 double i[7]; 3486 int j; 3487 }; 3488 $DECL_SPEC int parameterTypeFormat(struct DType2 param);"; 3489 $SOURCE2 .= " 3490 int parameterTypeFormat(struct DType2 param) { return 0; }"; 3491 3492 # Field_Type_Format 3493 $HEADER1 .= " 3494 struct FieldTypeFormat 3495 { 3496 int i; 3497 struct DType1 j; 3498 }; 3499 $DECL_SPEC int fieldTypeFormat(struct FieldTypeFormat param);"; 3500 $SOURCE1 .= " 3501 int fieldTypeFormat(struct FieldTypeFormat param) { return 0; }"; 3502 3503 $HEADER2 .= " 3504 struct FieldTypeFormat 3505 { 3506 int i; 3507 struct DType2 j; 3508 }; 3509 $DECL_SPEC int fieldTypeFormat(struct FieldTypeFormat param);"; 3510 $SOURCE2 .= " 3511 int fieldTypeFormat(struct FieldTypeFormat param) { return 0; }"; 3512 3513 # Parameter_Type_Format (struct to union) 3514 $HEADER1 .= " 3515 struct DType 3516 { 3517 int i; 3518 double j; 3519 }; 3520 $DECL_SPEC int parameterTypeFormat2(struct DType param);"; 3521 $SOURCE1 .= " 3522 int parameterTypeFormat2(struct DType param) { return 0; }"; 3523 3524 $HEADER2 .= " 3525 union DType 3526 { 3527 int i; 3528 long double j; 3529 }; 3530 $DECL_SPEC int parameterTypeFormat2(union DType param);"; 3531 $SOURCE2 .= " 3532 int parameterTypeFormat2(union DType param) { return 0; }"; 3533 3534 # Global_Data_Size 3535 $HEADER1 .= " 3536 struct GlobalDataSize { 3537 int a; 3538 }; 3539 $EXTERN $DECL_SPEC struct GlobalDataSize globalDataSize;"; 3540 3541 $HEADER2 .= " 3542 struct GlobalDataSize { 3543 int a, b; 3544 }; 3545 $EXTERN $DECL_SPEC struct GlobalDataSize globalDataSize;"; 3546 3547 # Global_Data_Type 3548 $HEADER1 .= " 3549 $EXTERN $DECL_SPEC int globalDataType;"; 3550 3551 $HEADER2 .= " 3552 $EXTERN $DECL_SPEC float globalDataType;"; 3553 3554 # Global_Data_Type_And_Size 3555 $HEADER1 .= " 3556 $EXTERN $DECL_SPEC int globalDataTypeAndSize;"; 3557 3558 $HEADER2 .= " 3559 $EXTERN $DECL_SPEC short globalDataTypeAndSize;"; 3560 3561 # Global_Data_Value_Changed 3562 # Integer 3563 $HEADER1 .= " 3564 $EXTERN $DECL_SPEC const int globalDataValue_Integer = 10;"; 3565 3566 $HEADER2 .= " 3567 $EXTERN $DECL_SPEC const int globalDataValue_Integer = 15;"; 3568 3569 # Global_Data_Value_Changed 3570 # Character 3571 $HEADER1 .= " 3572 $EXTERN $DECL_SPEC const char globalDataValue_Char = \'o\';"; 3573 3574 $HEADER2 .= " 3575 $EXTERN $DECL_SPEC const char globalDataValue_Char = \'N\';"; 3576 3577 # Global_Data_Became_Non_Const 3578 $HEADER1 .= " 3579 $EXTERN $DECL_SPEC const int globalDataBecameNonConst = 10;"; 3580 3581 $HEADER2 .= " 3582 extern $DECL_SPEC int globalDataBecameNonConst;"; 3583 $SOURCE2 .= " 3584 int globalDataBecameNonConst = 15;"; 3585 3586 # Global_Data_Became_Non_Const 3587 # Typedef 3588 $HEADER1 .= " 3589 typedef const int CONST_INT; 3590 $EXTERN $DECL_SPEC CONST_INT globalDataBecameNonConst_Typedef = 10;"; 3591 3592 $HEADER2 .= " 3593 extern $DECL_SPEC int globalDataBecameNonConst_Typedef;"; 3594 $SOURCE2 .= " 3595 int globalDataBecameNonConst_Typedef = 15;"; 3596 3597 # Global_Data_Became_Const 3598 $HEADER1 .= " 3599 extern $DECL_SPEC int globalDataBecameConst;"; 3600 $SOURCE1 .= " 3601 int globalDataBecameConst = 10;"; 3602 3603 $HEADER2 .= " 3604 $EXTERN $DECL_SPEC const int globalDataBecameConst = 15;"; 3605 3606 # Global_Data_Became_Non_Const 3607 $HEADER1 .= " 3608 struct GlobalDataType{int a;int b;struct GlobalDataType* p;}; 3609 $EXTERN $DECL_SPEC const struct GlobalDataType globalStructDataBecameNonConst = { 1, 2, (struct GlobalDataType*)0 };"; 3610 3611 $HEADER2 .= " 3612 struct GlobalDataType{int a;int b;struct GlobalDataType* p;}; 3613 $EXTERN $DECL_SPEC struct GlobalDataType globalStructDataBecameNonConst = { 1, 2, (struct GlobalDataType*)0 };"; 3614 3615 # Removed_Parameter 3616 $HEADER1 .= " 3617 $DECL_SPEC int removedParameter(int param, int removed_param);"; 3618 $SOURCE1 .= " 3619 int removedParameter(int param, int removed_param) { return 0; }"; 3620 3621 $HEADER2 .= " 3622 $DECL_SPEC int removedParameter(int param);"; 3623 $SOURCE2 .= " 3624 int removedParameter(int param) { return 0; }"; 3625 3626 # Added_Parameter 3627 $HEADER1 .= " 3628 $DECL_SPEC int addedParameter(int param);"; 3629 $SOURCE1 .= " 3630 int addedParameter(int param) { return param; }"; 3631 3632 $HEADER2 .= " 3633 $DECL_SPEC int addedParameter(int param, int added_param, int added_param2);"; 3634 $SOURCE2 .= " 3635 int addedParameter(int param, int added_param, int added_param2) { return added_param2; }"; 3636 3637 # Added_Interface (typedef to funcptr parameter) 3638 $HEADER2 .= " 3639 typedef int (*FUNCPTR_TYPE)(int a, int b); 3640 $DECL_SPEC int addedFunc(FUNCPTR_TYPE*const** f);"; 3641 $SOURCE2 .= " 3642 int addedFunc(FUNCPTR_TYPE*const** f) { return 0; }"; 3643 3644 # Added_Interface (funcptr parameter) 3645 $HEADER2 .= " 3646 $DECL_SPEC int addedFunc2(int(*func)(int, int));"; 3647 $SOURCE2 .= " 3648 int addedFunc2(int(*func)(int, int)) { return 0; }"; 3649 3650 # Added_Interface (no limited parameters) 3651 $HEADER2 .= " 3652 $DECL_SPEC int addedFunc3(float p1, ...);"; 3653 $SOURCE2 .= " 3654 int addedFunc3(float p1, ...) { return 0; }"; 3655 3656 # Size 3657 $HEADER1 .= " 3658 struct TypeSize 3659 { 3660 long long i[5]; 3661 long j; 3662 double k; 3663 struct TypeSize* p; 3664 }; 3665 $DECL_SPEC int testSize(struct TypeSize param, int param_2);"; 3666 $SOURCE1 .= " 3667 int testSize(struct TypeSize param, int param_2) { return param_2; }"; 3668 3669 $HEADER2 .= " 3670 struct TypeSize 3671 { 3672 long long i[15]; 3673 long long j; 3674 double k; 3675 struct TypeSize* p; 3676 }; 3677 $DECL_SPEC int testSize(struct TypeSize param, int param_2);"; 3678 $SOURCE2 .= " 3679 int testSize(struct TypeSize param, int param_2) { return param_2; }"; 3680 3681 # Added_Field_And_Size 3682 $HEADER1 .= " 3683 struct AddedFieldAndSize 3684 { 3685 int i; 3686 long j; 3687 double k; 3688 struct AddedFieldAndSize* p; 3689 }; 3690 $DECL_SPEC int addedFieldAndSize(struct AddedFieldAndSize param, int param_2);"; 3691 $SOURCE1 .= " 3692 int addedFieldAndSize(struct AddedFieldAndSize param, int param_2) { return param_2; }"; 3693 3694 $HEADER2 .= " 3695 struct AddedFieldAndSize 3696 { 3697 int i; 3698 long j; 3699 double k; 3700 struct AddedFieldAndSize* p; 3701 int added_member1; 3702 int added_member2; 3703 }; 3704 $DECL_SPEC int addedFieldAndSize(struct AddedFieldAndSize param, int param_2);"; 3705 $SOURCE2 .= " 3706 int addedFieldAndSize(struct AddedFieldAndSize param, int param_2) { return param_2; }"; 3707 3708 # Added_Middle_Field_And_Size 3709 $HEADER1 .= " 3710 struct AddedMiddleFieldAndSize 3711 { 3712 int i; 3713 long j; 3714 double k; 3715 struct AddedMiddleFieldAndSize* p; 3716 }; 3717 $DECL_SPEC int addedMiddleFieldAndSize(struct AddedMiddleFieldAndSize param, int param_2);"; 3718 $SOURCE1 .= " 3719 int addedMiddleFieldAndSize(struct AddedMiddleFieldAndSize param, int param_2) { return param_2; }"; 3720 3721 $HEADER2 .= " 3722 struct AddedMiddleFieldAndSize 3723 { 3724 int i; 3725 int added_middle_member; 3726 long j; 3727 double k; 3728 struct AddedMiddleFieldAndSize* p; 3729 }; 3730 $DECL_SPEC int addedMiddleFieldAndSize(struct AddedMiddleFieldAndSize param, int param_2);"; 3731 $SOURCE2 .= " 3732 int addedMiddleFieldAndSize(struct AddedMiddleFieldAndSize param, int param_2) { return param_2; }"; 3733 3734 # Added_Middle_Field 3735 $HEADER1 .= " 3736 struct AddedMiddleField 3737 { 3738 unsigned char field1; 3739 unsigned short field2; 3740 }; 3741 $DECL_SPEC int addedMiddleField(struct AddedMiddleField param, int param_2);"; 3742 $SOURCE1 .= " 3743 int addedMiddleField(struct AddedMiddleField param, int param_2) { return param_2; }"; 3744 3745 $HEADER2 .= " 3746 struct AddedMiddleField 3747 { 3748 unsigned char field1; 3749 unsigned char added_field; 3750 unsigned short field2; 3751 }; 3752 $DECL_SPEC int addedMiddleField(struct AddedMiddleField param, int param_2);"; 3753 $SOURCE2 .= " 3754 int addedMiddleField(struct AddedMiddleField param, int param_2) { return param_2; }"; 3755 3756 # Renamed_Field 3757 $HEADER1 .= " 3758 struct RenamedField 3759 { 3760 long i; 3761 long j; 3762 double k; 3763 struct RenamedField* p; 3764 }; 3765 $DECL_SPEC int renamedField(struct RenamedField param, int param_2);"; 3766 $SOURCE1 .= " 3767 int renamedField(struct RenamedField param, int param_2) { return param_2; }"; 3768 3769 $HEADER2 .= " 3770 struct RenamedField 3771 { 3772 long renamed_member; 3773 long j; 3774 double k; 3775 struct RenamedField* p; 3776 }; 3777 $DECL_SPEC int renamedField(struct RenamedField param, int param_2);"; 3778 $SOURCE2 .= " 3779 int renamedField(struct RenamedField param, int param_2) { return param_2; }"; 3780 3781 # Renamed_Field 3782 $HEADER1 .= " 3783 union RenamedUnionField 3784 { 3785 int renamed_from; 3786 double j; 3787 }; 3788 $DECL_SPEC int renamedUnionField(union RenamedUnionField param);"; 3789 $SOURCE1 .= " 3790 int renamedUnionField(union RenamedUnionField param) { return 0; }"; 3791 3792 $HEADER2 .= " 3793 union RenamedUnionField 3794 { 3795 int renamed_to; 3796 double j; 3797 }; 3798 $DECL_SPEC int renamedUnionField(union RenamedUnionField param);"; 3799 $SOURCE2 .= " 3800 int renamedUnionField(union RenamedUnionField param) { return 0; }"; 3801 3802 # Removed_Field_And_Size 3803 $HEADER1 .= " 3804 struct RemovedFieldAndSize 3805 { 3806 int i; 3807 long j; 3808 double k; 3809 struct RemovedFieldAndSize* p; 3810 int removed_member1; 3811 int removed_member2; 3812 }; 3813 $DECL_SPEC int removedFieldAndSize(struct RemovedFieldAndSize param, int param_2);"; 3814 $SOURCE1 .= " 3815 int removedFieldAndSize(struct RemovedFieldAndSize param, int param_2) { return param_2; }"; 3816 3817 $HEADER2 .= " 3818 struct RemovedFieldAndSize 3819 { 3820 int i; 3821 long j; 3822 double k; 3823 struct RemovedFieldAndSize* p; 3824 }; 3825 $DECL_SPEC int removedFieldAndSize(struct RemovedFieldAndSize param, int param_2);"; 3826 $SOURCE2 .= " 3827 int removedFieldAndSize(struct RemovedFieldAndSize param, int param_2) { return param_2; }"; 3828 3829 # Removed_Middle_Field 3830 $HEADER1 .= " 3831 struct RemovedMiddleField 3832 { 3833 int i; 3834 int removed_middle_member; 3835 long j; 3836 double k; 3837 struct RemovedMiddleField* p; 3838 }; 3839 $DECL_SPEC int removedMiddleField(struct RemovedMiddleField param, int param_2);"; 3840 $SOURCE1 .= " 3841 int removedMiddleField(struct RemovedMiddleField param, int param_2) { return param_2; }"; 3842 3843 $HEADER2 .= " 3844 struct RemovedMiddleField 3845 { 3846 int i; 3847 long j; 3848 double k; 3849 struct RemovedMiddleField* p; 3850 }; 3851 $DECL_SPEC int removedMiddleField(struct RemovedMiddleField param, int param_2);"; 3852 $SOURCE2 .= " 3853 int removedMiddleField(struct RemovedMiddleField param, int param_2) { return param_2; }"; 3854 3855 # Enum_Member_Value 3856 $HEADER1 .= " 3857 enum EnumMemberValue 3858 { 3859 MEMBER1=1, 3860 MEMBER2=2 3861 }; 3862 $DECL_SPEC int enumMemberValue(enum EnumMemberValue param);"; 3863 $SOURCE1 .= " 3864 int enumMemberValue(enum EnumMemberValue param) { return 0; }"; 3865 3866 $HEADER2 .= " 3867 enum EnumMemberValue 3868 { 3869 MEMBER1=2, 3870 MEMBER2=1 3871 }; 3872 $DECL_SPEC int enumMemberValue(enum EnumMemberValue param);"; 3873 $SOURCE2 .= " 3874 int enumMemberValue(enum EnumMemberValue param) { return 0; }"; 3875 3876 # Enum_Member_Removed 3877 $HEADER1 .= " 3878 enum EnumMemberRemoved 3879 { 3880 MEMBER=1, 3881 MEMBER_REMOVED=2 3882 }; 3883 $DECL_SPEC int enumMemberRemoved(enum EnumMemberRemoved param);"; 3884 $SOURCE1 .= " 3885 int enumMemberRemoved(enum EnumMemberRemoved param) { return 0; }"; 3886 3887 $HEADER2 .= " 3888 enum EnumMemberRemoved 3889 { 3890 MEMBER=1 3891 }; 3892 $DECL_SPEC int enumMemberRemoved(enum EnumMemberRemoved param);"; 3893 $SOURCE2 .= " 3894 int enumMemberRemoved(enum EnumMemberRemoved param) { return 0; }"; 3895 3896 # Enum_Member_Removed (middle) 3897 $HEADER1 .= " 3898 enum EnumMiddleMemberRemoved 3899 { 3900 MEM_REMOVED, 3901 MEM1, 3902 MEM2 3903 }; 3904 $DECL_SPEC int enumMiddleMemberRemoved(enum EnumMiddleMemberRemoved param);"; 3905 $SOURCE1 .= " 3906 int enumMiddleMemberRemoved(enum EnumMiddleMemberRemoved param) { return 0; }"; 3907 3908 $HEADER2 .= " 3909 enum EnumMiddleMemberRemoved 3910 { 3911 MEM1, 3912 MEM2 3913 }; 3914 $DECL_SPEC int enumMiddleMemberRemoved(enum EnumMiddleMemberRemoved param);"; 3915 $SOURCE2 .= " 3916 int enumMiddleMemberRemoved(enum EnumMiddleMemberRemoved param) { return 0; }"; 3917 3918 # Enum_Member_Name 3919 $HEADER1 .= " 3920 enum EnumMemberName 3921 { 3922 BRANCH1=1, 3923 BRANCH2=2 3924 }; 3925 $DECL_SPEC int enumMemberName(enum EnumMemberName param);"; 3926 $SOURCE1 .= " 3927 int enumMemberName(enum EnumMemberName param) { return 0; }"; 3928 3929 $HEADER2 .= " 3930 enum EnumMemberName 3931 { 3932 BRANCH_FIRST=1, 3933 BRANCH_SECOND=2 3934 }; 3935 $DECL_SPEC int enumMemberName(enum EnumMemberName param);"; 3936 $SOURCE2 .= " 3937 int enumMemberName(enum EnumMemberName param) { return 0; }"; 3938 3939 # Field_Type_And_Size 3940 $HEADER1 .= " 3941 struct FieldTypeAndSize 3942 { 3943 int i; 3944 long j; 3945 double k; 3946 struct FieldTypeAndSize* p; 3947 }; 3948 $DECL_SPEC int fieldTypeAndSize(struct FieldTypeAndSize param, int param_2);"; 3949 $SOURCE1 .= " 3950 int fieldTypeAndSize(struct FieldTypeAndSize param, int param_2) { return param_2; }"; 3951 3952 $HEADER2 .= " 3953 struct FieldTypeAndSize 3954 { 3955 int i; 3956 long long j; 3957 double k; 3958 struct FieldTypeAndSize* p; 3959 }; 3960 $DECL_SPEC int fieldTypeAndSize(struct FieldTypeAndSize param, int param_2);"; 3961 $SOURCE2 .= " 3962 int fieldTypeAndSize(struct FieldTypeAndSize param, int param_2) { return param_2; }"; 3963 3964 # Field_Type 3965 $HEADER1 .= " 3966 struct FieldType 3967 { 3968 int i; 3969 long j; 3970 double k; 3971 struct FieldType* p; 3972 }; 3973 $DECL_SPEC int fieldType(struct FieldType param, int param_2);"; 3974 $SOURCE1 .= " 3975 int fieldType(struct FieldType param, int param_2) { return param_2; }"; 3976 3977 $HEADER2 .= " 3978 struct FieldType 3979 { 3980 float i; 3981 long j; 3982 double k; 3983 struct FieldType* p; 3984 }; 3985 $DECL_SPEC int fieldType(struct FieldType param, int param_2);"; 3986 $SOURCE2 .= " 3987 int fieldType(struct FieldType param, int param_2) { return param_2; }"; 3988 3989 # Field_BaseType 3990 $HEADER1 .= " 3991 struct FieldBaseType 3992 { 3993 int i; 3994 long *j; 3995 double k; 3996 struct FieldBaseType* p; 3997 }; 3998 $DECL_SPEC int fieldBaseType(struct FieldBaseType param, int param_2);"; 3999 $SOURCE1 .= " 4000 int fieldBaseType(struct FieldBaseType param, int param_2) { return param_2; }"; 4001 4002 $HEADER2 .= " 4003 struct FieldBaseType 4004 { 4005 int i; 4006 long long *j; 4007 double k; 4008 struct FieldBaseType* p; 4009 }; 4010 $DECL_SPEC int fieldBaseType(struct FieldBaseType param, int param_2);"; 4011 $SOURCE2 .= " 4012 int fieldBaseType(struct FieldBaseType param, int param_2) { return param_2; }"; 4013 4014 # Field_PointerLevel (and Size) 4015 $HEADER1 .= " 4016 struct FieldPointerLevelAndSize 4017 { 4018 int i; 4019 long long j; 4020 double k; 4021 struct FieldPointerLevelAndSize* p; 4022 }; 4023 $DECL_SPEC int fieldPointerLevelAndSize(struct FieldPointerLevelAndSize param, int param_2);"; 4024 $SOURCE1 .= " 4025 int fieldPointerLevelAndSize(struct FieldPointerLevelAndSize param, int param_2) { return param_2; }"; 4026 4027 $HEADER2 .= " 4028 struct FieldPointerLevelAndSize 4029 { 4030 int i; 4031 long long *j; 4032 double k; 4033 struct FieldPointerLevelAndSize* p; 4034 }; 4035 $DECL_SPEC int fieldPointerLevelAndSize(struct FieldPointerLevelAndSize param, int param_2);"; 4036 $SOURCE2 .= " 4037 int fieldPointerLevelAndSize(struct FieldPointerLevelAndSize param, int param_2) { return param_2; }"; 4038 4039 # Field_PointerLevel 4040 $HEADER1 .= " 4041 struct FieldPointerLevel 4042 { 4043 int i; 4044 long *j; 4045 double k; 4046 struct FieldPointerLevel* p; 4047 }; 4048 $DECL_SPEC int fieldPointerLevel(struct FieldPointerLevel param, int param_2);"; 4049 $SOURCE1 .= " 4050 int fieldPointerLevel(struct FieldPointerLevel param, int param_2) { return param_2; }"; 4051 4052 $HEADER2 .= " 4053 struct FieldPointerLevel 4054 { 4055 int i; 4056 long **j; 4057 double k; 4058 struct FieldPointerLevel* p; 4059 }; 4060 $DECL_SPEC int fieldPointerLevel(struct FieldPointerLevel param, int param_2);"; 4061 $SOURCE2 .= " 4062 int fieldPointerLevel(struct FieldPointerLevel param, int param_2) { return param_2; }"; 4063 4064 # Added_Interface 4065 $HEADER2 .= " 4066 $DECL_SPEC int addedFunc4(int param);"; 4067 $SOURCE2 .= " 4068 int addedFunc4(int param) { return param; }"; 4069 4070 # Removed_Interface 4071 $HEADER1 .= " 4072 $DECL_SPEC int removedFunc(int param);"; 4073 $SOURCE1 .= " 4074 int removedFunc(int param) { return param; }"; 4075 4076 # Parameter_Type_And_Size 4077 $HEADER1 .= " 4078 $DECL_SPEC int parameterTypeAndSize(int param, int other_param);"; 4079 $SOURCE1 .= " 4080 int parameterTypeAndSize(int param, int other_param) { return other_param; }"; 4081 4082 $HEADER2 .= " 4083 $DECL_SPEC int parameterTypeAndSize(long long param, int other_param);"; 4084 $SOURCE2 .= " 4085 int parameterTypeAndSize(long long param, int other_param) { return other_param; }"; 4086 4087 # Parameter_Type_And_Size + Parameter_Became_Non_Const 4088 $HEADER1 .= " 4089 $DECL_SPEC int parameterTypeAndSizeBecameNonConst(int* const param, int other_param);"; 4090 $SOURCE1 .= " 4091 int parameterTypeAndSizeBecameNonConst(int* const param, int other_param) { return other_param; }"; 4092 4093 $HEADER2 .= " 4094 $DECL_SPEC int parameterTypeAndSizeBecameNonConst(long double param, int other_param);"; 4095 $SOURCE2 .= " 4096 int parameterTypeAndSizeBecameNonConst(long double param, int other_param) { return other_param; }"; 4097 4098 # Parameter_Type_And_Size (test calling conventions) 4099 $HEADER1 .= " 4100 $DECL_SPEC int parameterCallingConvention(int p1, int p2, int p3);"; 4101 $SOURCE1 .= " 4102 int parameterCallingConvention(int p1, int p2, int p3) { return 0; }"; 4103 4104 $HEADER2 .= " 4105 $DECL_SPEC float parameterCallingConvention(char p1, int p2, int p3);"; 4106 $SOURCE2 .= " 4107 float parameterCallingConvention(char p1, int p2, int p3) { return 7.0f; }"; 4108 4109 # Parameter_Type 4110 $HEADER1 .= " 4111 $DECL_SPEC int parameterType(int param, int other_param);"; 4112 $SOURCE1 .= " 4113 int parameterType(int param, int other_param) { return other_param; }"; 4114 4115 $HEADER2 .= " 4116 $DECL_SPEC int parameterType(float param, int other_param);"; 4117 $SOURCE2 .= " 4118 int parameterType(float param, int other_param) { return other_param; }"; 4119 4120 # Parameter_Became_Non_Const 4121 $HEADER1 .= " 4122 $DECL_SPEC int parameterBecameNonConst(int const* param);"; 4123 $SOURCE1 .= " 4124 int parameterBecameNonConst(int const* param) { return *param; }"; 4125 4126 $HEADER2 .= " 4127 $DECL_SPEC int parameterBecameNonConst(int* param);"; 4128 $SOURCE2 .= " 4129 int parameterBecameNonConst(int* param) { 4130 *param=10; 4131 return *param; 4132 }"; 4133 4134 # Parameter_Became_Non_Const + Parameter_Became_Non_Volatile 4135 $HEADER1 .= " 4136 $DECL_SPEC int parameterBecameNonConstNonVolatile(int const volatile* param);"; 4137 $SOURCE1 .= " 4138 int parameterBecameNonConstNonVolatile(int const volatile* param) { return *param; }"; 4139 4140 $HEADER2 .= " 4141 $DECL_SPEC int parameterBecameNonConstNonVolatile(int* param);"; 4142 $SOURCE2 .= " 4143 int parameterBecameNonConstNonVolatile(int* param) { 4144 *param=10; 4145 return *param; 4146 }"; 4147 4148 # Parameter_BaseType (Typedef) 4149 $HEADER1 .= " 4150 typedef int* PARAM_TYPEDEF; 4151 $DECL_SPEC int parameterBaseTypedefChange(PARAM_TYPEDEF param);"; 4152 $SOURCE1 .= " 4153 int parameterBaseTypedefChange(PARAM_TYPEDEF param) { return 0; }"; 4154 4155 $HEADER2 .= " 4156 typedef const int* PARAM_TYPEDEF; 4157 $DECL_SPEC int parameterBaseTypedefChange(PARAM_TYPEDEF param);"; 4158 $SOURCE2 .= " 4159 int parameterBaseTypedefChange(PARAM_TYPEDEF param) { return 0; }"; 4160 4161 # Parameter_BaseType 4162 $HEADER1 .= " 4163 $DECL_SPEC int parameterBaseTypeChange(int *param);"; 4164 $SOURCE1 .= " 4165 int parameterBaseTypeChange(int *param) { return sizeof(*param); }"; 4166 4167 $HEADER2 .= " 4168 $DECL_SPEC int parameterBaseTypeChange(long long *param);"; 4169 $SOURCE2 .= " 4170 int parameterBaseTypeChange(long long *param) { return sizeof(*param); }"; 4171 4172 # Parameter_PointerLevel 4173 $HEADER1 .= " 4174 $DECL_SPEC long long parameterPointerLevelAndSize(long long param);"; 4175 $SOURCE1 .= " 4176 long long parameterPointerLevelAndSize(long long param) { return param; }"; 4177 4178 $HEADER2 .= " 4179 $DECL_SPEC long long parameterPointerLevelAndSize(long long *param);"; 4180 $SOURCE2 .= " 4181 long long parameterPointerLevelAndSize(long long *param) { return param[5]; }"; 4182 4183 # Parameter_PointerLevel 4184 $HEADER1 .= " 4185 $DECL_SPEC int parameterPointerLevel(int *param);"; 4186 $SOURCE1 .= " 4187 int parameterPointerLevel(int *param) { return param[5]; }"; 4188 4189 $HEADER2 .= " 4190 $DECL_SPEC int parameterPointerLevel(int **param);"; 4191 $SOURCE2 .= " 4192 int parameterPointerLevel(int **param) { return param[5][5]; }"; 4193 4194 # Return_Type_And_Size 4195 $HEADER1 .= " 4196 $DECL_SPEC int returnTypeAndSize(int param);"; 4197 $SOURCE1 .= " 4198 int returnTypeAndSize(int param) { return 0; }"; 4199 4200 $HEADER2 .= " 4201 $DECL_SPEC long long returnTypeAndSize(int param);"; 4202 $SOURCE2 .= " 4203 long long returnTypeAndSize(int param) { return 0; }"; 4204 4205 # Return_Type 4206 $HEADER1 .= " 4207 $DECL_SPEC int returnType(int param);"; 4208 $SOURCE1 .= " 4209 int returnType(int param) { return 1; }"; 4210 4211 $HEADER2 .= " 4212 $DECL_SPEC float returnType(int param);"; 4213 $SOURCE2 .= " 4214 float returnType(int param) { return 1; }"; 4215 4216 # Return_Type_Became_Void ("int" to "void") 4217 $HEADER1 .= " 4218 $DECL_SPEC int returnTypeChangeToVoid(int param);"; 4219 $SOURCE1 .= " 4220 int returnTypeChangeToVoid(int param) { return 0; }"; 4221 4222 $HEADER2 .= " 4223 $DECL_SPEC void returnTypeChangeToVoid(int param);"; 4224 $SOURCE2 .= " 4225 void returnTypeChangeToVoid(int param) { return; }"; 4226 4227 # Return_Type ("struct" to "void*") 4228 $HEADER1 .= " 4229 struct SomeStruct { 4230 int a; 4231 double b, c, d; 4232 }; 4233 $DECL_SPEC struct SomeStruct* returnTypeChangeToVoidPtr(int param);"; 4234 $SOURCE1 .= " 4235 struct SomeStruct* returnTypeChangeToVoidPtr(int param) { return (struct SomeStruct*)0; }"; 4236 4237 $HEADER2 .= " 4238 struct SomeStruct { 4239 int a; 4240 double b, c, d; 4241 }; 4242 $DECL_SPEC void* returnTypeChangeToVoidPtr(int param);"; 4243 $SOURCE2 .= " 4244 void* returnTypeChangeToVoidPtr(int param) { return (void*)0; }"; 4245 4246 # Return_Type (structure change) 4247 $HEADER1 .= " 4248 struct SomeStruct2 { 4249 int a; 4250 int b; 4251 }; 4252 $DECL_SPEC struct SomeStruct2 returnType2(int param);"; 4253 $SOURCE1 .= " 4254 struct SomeStruct2 returnType2(int param) { struct SomeStruct2 r = {1, 2};return r; }"; 4255 4256 $HEADER2 .= " 4257 struct SomeStruct2 { 4258 int a; 4259 }; 4260 $DECL_SPEC struct SomeStruct2 returnType2(int param);"; 4261 $SOURCE2 .= " 4262 struct SomeStruct2 returnType2(int param) { struct SomeStruct2 r = {1};return r; }"; 4263 4264 # Return_Type (structure change) 4265 $HEADER1 .= " 4266 struct SomeStruct3 { 4267 int a; 4268 int b; 4269 }; 4270 $DECL_SPEC struct SomeStruct3 returnType3(int param);"; 4271 $SOURCE1 .= " 4272 struct SomeStruct3 returnType3(int param) { struct SomeStruct3 r = {1, 2};return r; }"; 4273 4274 $HEADER2 .= " 4275 struct SomeStruct3 { 4276 int a; 4277 long double b; 4278 }; 4279 $DECL_SPEC struct SomeStruct3 returnType3(int param);"; 4280 $SOURCE2 .= " 4281 struct SomeStruct3 returnType3(int param) { struct SomeStruct3 r = {1, 2.0L};return r; }"; 4282 4283 # Return_Type_From_Void_And_Stack_Layout ("void" to "struct") 4284 $HEADER1 .= " 4285 $DECL_SPEC void returnTypeChangeFromVoidToStruct(int param);"; 4286 $SOURCE1 .= " 4287 void returnTypeChangeFromVoidToStruct(int param) { return; }"; 4288 4289 $HEADER2 .= " 4290 $DECL_SPEC struct SomeStruct returnTypeChangeFromVoidToStruct(int param);"; 4291 $SOURCE2 .= " 4292 struct SomeStruct returnTypeChangeFromVoidToStruct(int param) { 4293 struct SomeStruct obj = {1,2}; 4294 return obj; 4295 }"; 4296 4297 # Return_Type_Became_Void_And_Stack_Layout ("struct" to "void") 4298 $HEADER1 .= " 4299 $DECL_SPEC struct SomeStruct returnTypeChangeFromStructToVoid(int param);"; 4300 $SOURCE1 .= " 4301 struct SomeStruct returnTypeChangeFromStructToVoid(int param) { 4302 struct SomeStruct obj = {1,2}; 4303 return obj; 4304 }"; 4305 4306 $HEADER2 .= " 4307 $DECL_SPEC void returnTypeChangeFromStructToVoid(int param);"; 4308 $SOURCE2 .= " 4309 void returnTypeChangeFromStructToVoid(int param) { return; }"; 4310 4311 # Return_Type_From_Void_And_Stack_Layout (safe, "void" to "long") 4312 $HEADER1 .= " 4313 $DECL_SPEC void returnTypeChangeFromVoidToLong(int param);"; 4314 $SOURCE1 .= " 4315 void returnTypeChangeFromVoidToLong(int param) { return; }"; 4316 4317 $HEADER2 .= " 4318 $DECL_SPEC long returnTypeChangeFromVoidToLong(int param);"; 4319 $SOURCE2 .= " 4320 long returnTypeChangeFromVoidToLong(int param) { return 0; }"; 4321 4322 # Return_Type_From_Void_And_Stack_Layout (safe, "void" to "void*") 4323 $HEADER1 .= " 4324 $DECL_SPEC void returnTypeChangeFromVoidToVoidPtr(int param);"; 4325 $SOURCE1 .= " 4326 void returnTypeChangeFromVoidToVoidPtr(int param) { return; }"; 4327 4328 $HEADER2 .= " 4329 $DECL_SPEC void* returnTypeChangeFromVoidToVoidPtr(int param);"; 4330 $SOURCE2 .= " 4331 void* returnTypeChangeFromVoidToVoidPtr(int param) { return 0; }"; 4332 4333 # Return_Type_From_Register_To_Stack ("int" to "struct") 4334 $HEADER1 .= " 4335 $DECL_SPEC int returnTypeChangeFromIntToStruct(int param);"; 4336 $SOURCE1 .= " 4337 int returnTypeChangeFromIntToStruct(int param) { return param; }"; 4338 4339 $HEADER2 .= " 4340 $DECL_SPEC struct SomeStruct returnTypeChangeFromIntToStruct(int param);"; 4341 $SOURCE2 .= " 4342 struct SomeStruct returnTypeChangeFromIntToStruct(int param) { 4343 struct SomeStruct obj = {1,2}; 4344 return obj; 4345 }"; 4346 4347 # Return_Type_From_Stack_To_Register (from struct to int) 4348 $HEADER1 .= " 4349 $DECL_SPEC struct SomeStruct returnTypeChangeFromStructToInt(int param);"; 4350 $SOURCE1 .= " 4351 struct SomeStruct returnTypeChangeFromStructToInt(int param) { 4352 struct SomeStruct obj = {1,2}; 4353 return obj; 4354 }"; 4355 4356 $HEADER2 .= " 4357 $DECL_SPEC int returnTypeChangeFromStructToInt(int param);"; 4358 $SOURCE2 .= " 4359 int returnTypeChangeFromStructToInt(int param) { return param; }"; 4360 4361 # Return_Type_From_Stack_To_Register (from struct to int, without parameters) 4362 $HEADER1 .= " 4363 $DECL_SPEC struct SomeStruct returnTypeChangeFromStructToIntWithNoParams();"; 4364 $SOURCE1 .= " 4365 struct SomeStruct returnTypeChangeFromStructToIntWithNoParams() { 4366 struct SomeStruct obj = {1,2}; 4367 return obj; 4368 }"; 4369 4370 $HEADER2 .= " 4371 $DECL_SPEC int returnTypeChangeFromStructToIntWithNoParams();"; 4372 $SOURCE2 .= " 4373 int returnTypeChangeFromStructToIntWithNoParams() { return 0; }"; 4374 4375 # Return_BaseType 4376 $HEADER1 .= " 4377 $DECL_SPEC int *returnBaseTypeChange(int param);"; 4378 $SOURCE1 .= " 4379 int *returnBaseTypeChange(int param) { return (int*)0; }"; 4380 4381 $HEADER2 .= " 4382 $DECL_SPEC long long *returnBaseTypeChange(int param);"; 4383 $SOURCE2 .= " 4384 long long *returnBaseTypeChange(int param) { return (long long*)0; }"; 4385 4386 # Return_PointerLevel 4387 $HEADER1 .= " 4388 $DECL_SPEC long long returnPointerLevelAndSize(int param);"; 4389 $SOURCE1 .= " 4390 long long returnPointerLevelAndSize(int param) { return 100; }"; 4391 4392 $HEADER2 .= " 4393 $DECL_SPEC long long *returnPointerLevelAndSize(int param);"; 4394 $SOURCE2 .= " 4395 long long *returnPointerLevelAndSize(int param) { return (long long *)0; }"; 4396 4397 # Return_PointerLevel 4398 $HEADER1 .= " 4399 $DECL_SPEC long long *returnPointerLevel(int param);"; 4400 $SOURCE1 .= " 4401 long long *returnPointerLevel(int param) { return (long long *)0; }"; 4402 4403 $HEADER2 .= " 4404 $DECL_SPEC long long **returnPointerLevel(int param);"; 4405 $SOURCE2 .= " 4406 long long **returnPointerLevel(int param) { return (long long **)0; }"; 4407 4408 # Size (typedef to anon structure) 4409 $HEADER1 .= " 4410 typedef struct 4411 { 4412 int i; 4413 long j; 4414 double k; 4415 } AnonTypedef; 4416 $DECL_SPEC int anonTypedef(AnonTypedef param);"; 4417 $SOURCE1 .= " 4418 int anonTypedef(AnonTypedef param) { return 0; }"; 4419 4420 $HEADER2 .= " 4421 typedef struct 4422 { 4423 int i; 4424 long j; 4425 double k; 4426 union { 4427 int dummy[256]; 4428 struct { 4429 char q_skiptable[256]; 4430 const char *p; 4431 int l; 4432 } p; 4433 }; 4434 } AnonTypedef; 4435 $DECL_SPEC int anonTypedef(AnonTypedef param);"; 4436 $SOURCE2 .= " 4437 int anonTypedef(AnonTypedef param) { return 0; }"; 4438 4439 # Size (safe: opaque) 4440 $HEADER1 .= " 4441 struct OpaqueType 4442 { 4443 long long i[5]; 4444 long j; 4445 double k; 4446 struct OpaqueType* p; 4447 }; 4448 $DECL_SPEC int opaqueTypeUse(struct OpaqueType param, int param_2);"; 4449 $SOURCE1 .= " 4450 int opaqueTypeUse(struct OpaqueType param, int param_2) { return param_2; }"; 4451 4452 $HEADER2 .= " 4453 struct OpaqueType 4454 { 4455 long long i[5]; 4456 long long j; 4457 double k; 4458 struct OpaqueType* p; 4459 }; 4460 $DECL_SPEC int opaqueTypeUse(struct OpaqueType param, int param_2);"; 4461 $SOURCE2 .= " 4462 int opaqueTypeUse(struct OpaqueType param, int param_2) { return param_2; }"; 4463 4464 # Size (safe: internal) 4465 $HEADER1 .= " 4466 struct InternalType 4467 { 4468 long long i[5]; 4469 long j; 4470 double k; 4471 struct InternalType* p; 4472 }; 4473 $DECL_SPEC int internalTypeUse(struct InternalType param, int param_2);"; 4474 $SOURCE1 .= " 4475 int internalTypeUse(struct InternalType param, int param_2) { return param_2; }"; 4476 4477 $HEADER2 .= " 4478 struct InternalType 4479 { 4480 long long i[5]; 4481 long long j; 4482 double k; 4483 struct InternalType* p; 4484 }; 4485 $DECL_SPEC int internalTypeUse(struct InternalType param, int param_2);"; 4486 $SOURCE2 .= " 4487 int internalTypeUse(struct InternalType param, int param_2) { return param_2; }"; 4488 4489 if($In::Opt{"OS"} eq "linux") 4490 { 4491 # Changed version 4492 $HEADER1 .= " 4493 $DECL_SPEC int changedVersion(int param); 4494 $DECL_SPEC int changedDefaultVersion(int param);"; 4495 $SOURCE1 .= " 4496 int changedVersion(int param) { return 0; } 4497 __asm__(\".symver changedVersion,changedVersion\@VERSION_2.0\"); 4498 int changedDefaultVersion(int param) { return 0; }"; 4499 4500 $HEADER2 .= " 4501 $DECL_SPEC int changedVersion(int param); 4502 $DECL_SPEC int changedDefaultVersion(long param);"; 4503 $SOURCE2 .= " 4504 int changedVersion(int param) { return 0; } 4505 __asm__(\".symver changedVersion,changedVersion\@VERSION_3.0\"); 4506 int changedDefaultVersion(long param) { return 0; }"; 4507 4508 # Unchanged version 4509 $HEADER1 .= " 4510 $DECL_SPEC int unchangedVersion(int param); 4511 $DECL_SPEC int unchangedDefaultVersion(int param);"; 4512 $SOURCE1 .= " 4513 int unchangedVersion(int param) { return 0; } 4514 __asm__(\".symver unchangedVersion,unchangedVersion\@VERSION_1.0\"); 4515 int unchangedDefaultVersion(int param) { return 0; }"; 4516 4517 $HEADER2 .= " 4518 $DECL_SPEC int unchangedVersion(int param); 4519 $DECL_SPEC int unchangedDefaultVersion(int param);"; 4520 $SOURCE2 .= " 4521 int unchangedVersion(int param) { return 0; } 4522 __asm__(\".symver unchangedVersion,unchangedVersion\@VERSION_1.0\"); 4523 int unchangedDefaultVersion(int param) { return 0; }"; 4524 4525 # Non-Default to Default 4526 $HEADER1 .= " 4527 $DECL_SPEC int changedVersionToDefault(int param);"; 4528 $SOURCE1 .= " 4529 int changedVersionToDefault(int param) { return 0; } 4530 __asm__(\".symver changedVersionToDefault,changedVersionToDefault\@VERSION_1.0\");"; 4531 4532 $HEADER2 .= " 4533 $DECL_SPEC int changedVersionToDefault(long param);"; 4534 $SOURCE2 .= " 4535 int changedVersionToDefault(long param) { return 0; }"; 4536 4537 # Default to Non-Default 4538 $HEADER1 .= " 4539 $DECL_SPEC int changedVersionToNonDefault(int param);"; 4540 $SOURCE1 .= " 4541 int changedVersionToNonDefault(int param) { return 0; }"; 4542 4543 $HEADER2 .= " 4544 $DECL_SPEC int changedVersionToNonDefault(long param);"; 4545 $SOURCE2 .= " 4546 int changedVersionToNonDefault(long param) { return 0; } 4547 __asm__(\".symver changedVersionToNonDefault,changedVersionToNonDefault\@VERSION_3.0\");"; 4548 4549 # Added version 4550 $HEADER1 .= " 4551 $DECL_SPEC int addedVersion(int param); 4552 $DECL_SPEC int addedDefaultVersion(int param);"; 4553 $SOURCE1 .= " 4554 int addedVersion(int param) { return 0; } 4555 int addedDefaultVersion(int param) { return 0; }"; 4556 4557 $HEADER2 .= " 4558 $DECL_SPEC int addedVersion(int param); 4559 $DECL_SPEC int addedDefaultVersion(int param);"; 4560 $SOURCE2 .= " 4561 int addedVersion(int param) { return 0; } 4562 __asm__(\".symver addedVersion,addedVersion\@VERSION_2.0\"); 4563 int addedDefaultVersion(int param) { return 0; }"; 4564 4565 # Removed version 4566 $HEADER1 .= " 4567 $DECL_SPEC int removedVersion(int param); 4568 $DECL_SPEC int removedVersion2(int param); 4569 $DECL_SPEC int removedDefaultVersion(int param);"; 4570 $SOURCE1 .= " 4571 int removedVersion(int param) { return 0; } 4572 __asm__(\".symver removedVersion,removedVersion\@VERSION_1.0\"); 4573 int removedVersion2(int param) { return 0; } 4574 __asm__(\".symver removedVersion2,removedVersion\@VERSION_3.0\"); 4575 int removedDefaultVersion(int param) { return 0; }"; 4576 4577 $HEADER2 .= " 4578 $DECL_SPEC int removedVersion(int param); 4579 $DECL_SPEC int removedVersion2(int param); 4580 $DECL_SPEC int removedDefaultVersion(int param);"; 4581 $SOURCE2 .= " 4582 int removedVersion(int param) { return 0; } 4583 int removedVersion2(int param) { return 0; } 4584 __asm__(\".symver removedVersion2,removedVersion\@VERSION_3.0\"); 4585 int removedDefaultVersion(int param) { return 0; }"; 4586 4587 # Return_Type (good versioning) 4588 $HEADER1 .= " 4589 $DECL_SPEC int goodVersioning(int param);"; 4590 $SOURCE1 .= " 4591 int goodVersioning(int param) { return 0; } 4592 __asm__(\".symver goodVersioning,goodVersioning\@VERSION_1.0\");"; 4593 4594 $HEADER2 .= " 4595 $DECL_SPEC int goodVersioningOld(int param);"; 4596 $SOURCE2 .= " 4597 int goodVersioningOld(int param) { return 0; } 4598 __asm__(\".symver goodVersioningOld,goodVersioning\@VERSION_1.0\");"; 4599 4600 $HEADER2 .= " 4601 $DECL_SPEC float goodVersioning(int param);"; 4602 $SOURCE2 .= " 4603 float goodVersioning(int param) { return 0.7; } 4604 __asm__(\".symver goodVersioning,goodVersioning\@VERSION_2.0\");"; 4605 4606 # Return_Type (bad versioning) 4607 $HEADER1 .= " 4608 $DECL_SPEC int badVersioning(int param);"; 4609 $SOURCE1 .= " 4610 int badVersioning(int param) { return 0; } 4611 __asm__(\".symver badVersioning,badVersioning\@VERSION_1.0\");"; 4612 4613 $HEADER2 .= " 4614 $DECL_SPEC float badVersioningOld(int param);"; 4615 $SOURCE2 .= " 4616 float badVersioningOld(int param) { return 0.7; } 4617 __asm__(\".symver badVersioningOld,badVersioning\@VERSION_1.0\");"; 4618 4619 $HEADER2 .= " 4620 $DECL_SPEC float badVersioning(int param);"; 4621 $SOURCE2 .= " 4622 float badVersioning(int param) { return 0.7; } 4623 __asm__(\".symver badVersioning,badVersioning\@VERSION_2.0\");"; 4624 } 4625 # unnamed struct/union fields within structs/unions 4626 $HEADER1 .= " 4627 typedef struct 4628 { 4629 int a; 4630 union { 4631 int b; 4632 float c; 4633 }; 4634 int d; 4635 } UnnamedTypeSize; 4636 $DECL_SPEC int unnamedTypeSize(UnnamedTypeSize param);"; 4637 $SOURCE1 .= " 4638 int unnamedTypeSize(UnnamedTypeSize param) { return 0; }"; 4639 4640 $HEADER2 .= " 4641 typedef struct 4642 { 4643 int a; 4644 union { 4645 long double b; 4646 float c; 4647 }; 4648 int d; 4649 } UnnamedTypeSize; 4650 $DECL_SPEC int unnamedTypeSize(UnnamedTypeSize param);"; 4651 $SOURCE2 .= " 4652 int unnamedTypeSize(UnnamedTypeSize param) { return 0; }"; 4653 4654 # Changed_Constant (#define) 4655 $HEADER1 .= " 4656 #define PUBLIC_CONSTANT \"old_value\""; 4657 $HEADER2 .= " 4658 #define PUBLIC_CONSTANT \"new_value\""; 4659 4660 # Changed_Constant (Safe) 4661 $HEADER1 .= " 4662 #define INTEGER_CONSTANT 0x01"; 4663 $HEADER2 .= " 4664 #define INTEGER_CONSTANT 1"; 4665 4666 # Changed_Constant (Safe) 4667 $HEADER1 .= " 4668 #define PRIVATE_CONSTANT \"old_value\" 4669 #undef PRIVATE_CONSTANT"; 4670 $HEADER2 .= " 4671 #define PRIVATE_CONSTANT \"new_value\" 4672 #undef PRIVATE_CONSTANT"; 4673 4674 # Changed_Constant (enum) 4675 $HEADER1 .= " 4676 enum { 4677 SOME_CONSTANT=0x1 4678 };"; 4679 $HEADER2 .= " 4680 enum { 4681 SOME_CONSTANT=0x2 4682 };"; 4683 4684 # Added_Constant (#define) 4685 $HEADER2 .= " 4686 #define ADDED_CNST \"value\""; 4687 4688 # Added_Constant (enum) 4689 $HEADER1 .= " 4690 enum { 4691 CONSTANT1 4692 };"; 4693 $HEADER2 .= " 4694 enum { 4695 CONSTANT1, 4696 ADDED_CONSTANT 4697 };"; 4698 4699 # Removed_Constant (#define) 4700 $HEADER1 .= " 4701 #define REMOVED_CNST \"value\""; 4702 4703 # Removed_Constant (enum) 4704 $HEADER1 .= " 4705 enum { 4706 CONSTANT2, 4707 REMOVED_CONSTANT 4708 };"; 4709 $HEADER2 .= " 4710 enum { 4711 CONSTANT2 4712 };"; 4713 4714 # Added_Field (union) 4715 $HEADER1 .= " 4716 union UnionTypeAddedField 4717 { 4718 int a; 4719 struct { 4720 int b; 4721 float c; 4722 }; 4723 int d; 4724 }; 4725 $DECL_SPEC int unionTypeAddedField(union UnionTypeAddedField param);"; 4726 $SOURCE1 .= " 4727 int unionTypeAddedField(union UnionTypeAddedField param) { return 0; }"; 4728 4729 $HEADER2 .= " 4730 union UnionTypeAddedField 4731 { 4732 int a; 4733 struct { 4734 long double x, y; 4735 } new_field; 4736 struct { 4737 int b; 4738 float c; 4739 }; 4740 int d; 4741 }; 4742 $DECL_SPEC int unionTypeAddedField(union UnionTypeAddedField param);"; 4743 $SOURCE2 .= " 4744 int unionTypeAddedField(union UnionTypeAddedField param) { return 0; }"; 4745 4746 # Prameter_BaseType (typedef) 4747 $HEADER1 .= " 4748 typedef float TYPEDEF_TYPE; 4749 $DECL_SPEC int parameterTypedefChange(TYPEDEF_TYPE param);"; 4750 $SOURCE1 .= " 4751 int parameterTypedefChange(TYPEDEF_TYPE param) { return 1.0; }"; 4752 4753 $HEADER2 .= " 4754 typedef int TYPEDEF_TYPE; 4755 $DECL_SPEC int parameterTypedefChange(TYPEDEF_TYPE param);"; 4756 $SOURCE2 .= " 4757 int parameterTypedefChange(TYPEDEF_TYPE param) { return 1; }"; 4758 4759 # Field_BaseType (typedef in member type) 4760 $HEADER1 .= " 4761 typedef float TYPEDEF_TYPE_2; 4762 struct FieldBaseTypedefChange { 4763 TYPEDEF_TYPE_2 m; 4764 }; 4765 $DECL_SPEC int fieldBaseTypedefChange(struct FieldBaseTypedefChange param);"; 4766 $SOURCE1 .= " 4767 int fieldBaseTypedefChange(struct FieldBaseTypedefChange param) { return 1; }"; 4768 4769 $HEADER2 .= " 4770 typedef int TYPEDEF_TYPE_2; 4771 struct FieldBaseTypedefChange { 4772 TYPEDEF_TYPE_2 m; 4773 }; 4774 $DECL_SPEC int fieldBaseTypedefChange(struct FieldBaseTypedefChange param);"; 4775 $SOURCE2 .= " 4776 int fieldBaseTypedefChange(struct FieldBaseTypedefChange param) { return 1; }"; 4777 4778 # C++ keywords in C code 4779 $HEADER1 .= " 4780 $DECL_SPEC int testCppKeywords1(int class, int virtual, int (*new)(int));"; 4781 $SOURCE1 .= " 4782 $DECL_SPEC int testCppKeywords1(int class, int virtual, int (*new)(int)) { return 0; }"; 4783 4784 $HEADER2 .= " 4785 $DECL_SPEC int testCppKeywords1(int class, int virtual); 4786 $DECL_SPEC int testCppKeywords2(int operator, int other); 4787 $DECL_SPEC int testCppKeywords3(int operator); 4788 $DECL_SPEC int operator(int class, int this); 4789 $DECL_SPEC int delete(int virtual, int* this); 4790 $DECL_SPEC int testCppKeywords4(int* param, int export); 4791 struct CppKeywords { 4792 int bool: 8; 4793 //int*this; 4794 }; 4795 #ifdef __cplusplus 4796 class TestCppKeywords { 4797 void operator delete(void*); 4798 void operator ()(int); 4799 void operator,(int); 4800 void delete() { 4801 delete this; 4802 }; 4803 }; 4804 #endif"; 4805 $SOURCE2 .= " 4806 $DECL_SPEC int testCppKeywords1(int class, int virtual) { return 0; } 4807 $DECL_SPEC int testCppKeywords2(int operator, int other) { return 0; } 4808 $DECL_SPEC int testCppKeywords3(int operator) { return 0; } 4809 $DECL_SPEC int operator(int class, int this) { return 0; } 4810 $DECL_SPEC int delete(int virtual, int* this) { return 0; } 4811 $DECL_SPEC int testCppKeywords4(int* param, int export) { return 0; }"; 4812 4813 # Regression 4814 $HEADER1 .= " 4815 $DECL_SPEC int* testRegression(int *pointer, char const *name, ...);"; 4816 $SOURCE1 .= " 4817 int* testRegression(int *pointer, char const *name, ...) { return 0; }"; 4818 4819 $HEADER2 .= " 4820 $DECL_SPEC int* testRegression(int *pointer, char const *name, ...);"; 4821 $SOURCE2 .= " 4822 int* testRegression(int *pointer, char const *name, ...) { return 0; }"; 4823 4824 runTests("libsample_c", "C", $HEADER1, $SOURCE1, $HEADER2, $SOURCE2, "struct OpaqueType", "internalTypeUse"); 4825} 4826 4827sub runTests($$$$$$$$) 4828{ 4829 my ($LibName, $Lang, $HEADER1, $SOURCE1, $HEADER2, $SOURCE2, $Opaque, $Private) = @_; 4830 4831 my $LExt = $In::Opt{"Ext"}; 4832 my $GccPath = $In::Opt{"GccPath"}; 4833 4834 my $SrcE = ($Lang eq "C++")?"cpp":"c"; 4835 rmtree($LibName); 4836 4837 my $ObjName = "libsample"; 4838 4839 # creating test suite 4840 my $Path_v1 = "$LibName/$ObjName.v1"; 4841 my $Path_v2 = "$LibName/$ObjName.v2"; 4842 mkpath($Path_v1); 4843 mkpath($Path_v2); 4844 writeFile("$Path_v1/$ObjName.h", $HEADER1."\n"); 4845 writeFile("$Path_v1/$ObjName.$SrcE", "#include \"$ObjName.h\"\n".$SOURCE1."\n"); 4846 4847 writeFile("$LibName/v1.xml", " 4848 <version> 4849 1.0 4850 </version> 4851 4852 <headers> 4853 ".getAbsPath($Path_v1)." 4854 </headers> 4855 4856 <libs> 4857 ".getAbsPath($Path_v1)." 4858 </libs> 4859 4860 <include_paths> 4861 ".getAbsPath($Path_v1)." 4862 </include_paths> 4863 "); 4864 4865 writeFile("$Path_v1/test.$SrcE", " 4866 #include \"$ObjName.h\" 4867 #include <stdio.h> 4868 ".($Lang eq "C++"?"using namespace TestNS;":"")." 4869 int main() 4870 { 4871 int ret = 0; 4872 printf(\"\%d\\n\", ret); 4873 return 0; 4874 } 4875 "); 4876 4877 writeFile("$Path_v2/$ObjName.h", $HEADER2."\n"); 4878 writeFile("$Path_v2/$ObjName.$SrcE", "#include \"$ObjName.h\"\n".$SOURCE2."\n"); 4879 writeFile("$LibName/v2.xml", " 4880 <version> 4881 2.0 4882 </version> 4883 4884 <headers> 4885 ".getAbsPath($Path_v2)." 4886 </headers> 4887 4888 <libs> 4889 ".getAbsPath($Path_v2)." 4890 </libs> 4891 4892 <include_paths> 4893 ".getAbsPath($Path_v2)." 4894 </include_paths> 4895 "); 4896 4897 writeFile("$Path_v2/test.$SrcE", " 4898 #include \"$ObjName.h\" 4899 #include <stdio.h> 4900 ".($Lang eq "C++"?"using namespace TestNS;":"")." 4901 int main() 4902 { 4903 int ret = 0; 4904 printf(\"\%d\\n\", ret); 4905 return 0; 4906 } 4907 "); 4908 4909 writeFile("$LibName/filt.xml", " 4910 <skip_types> 4911 $Opaque 4912 </skip_types> 4913 4914 <skip_symbols> 4915 $Private 4916 </skip_symbols> 4917 "); 4918 4919 my ($BuildCmd, $BuildCmd_Test) = ("", ""); 4920 4921 if($In::Opt{"OS"} eq "linux") 4922 { 4923 if($Lang eq "C") 4924 { # tests for symbol versioning 4925 writeFile("$Path_v1/version", " 4926 VERSION_1.0 { 4927 unchangedDefaultVersion; 4928 removedDefaultVersion; 4929 }; 4930 VERSION_2.0 { 4931 changedDefaultVersion; 4932 }; 4933 VERSION_3.0 { 4934 changedVersionToNonDefault; 4935 }; 4936 "); 4937 writeFile("$Path_v2/version", " 4938 VERSION_1.0 { 4939 unchangedDefaultVersion; 4940 changedVersionToDefault; 4941 }; 4942 VERSION_2.0 { 4943 addedDefaultVersion; 4944 }; 4945 VERSION_3.0 { 4946 changedDefaultVersion; 4947 }; 4948 "); 4949 $BuildCmd = $GccPath." -Wl,--version-script version -shared $ObjName.$SrcE -o $ObjName.$LExt -g -Og"; 4950 $BuildCmd_Test = $GccPath." -Wl,--version-script version test.$SrcE -Wl,$ObjName.$LExt -o test"; 4951 } 4952 else 4953 { 4954 $BuildCmd = $GccPath." -shared -x c++ $ObjName.$SrcE -lstdc++ -o $ObjName.$LExt -g -Og"; 4955 $BuildCmd_Test = $GccPath." -x c++ test.$SrcE -lstdc++ -Wl,$ObjName.$LExt -o test"; 4956 } 4957 if(getArch_GCC(1)=~/\A(arm|x86_64)\Z/i) 4958 { # relocation R_ARM_MOVW_ABS_NC against `a local symbol' can not be used when making a shared object; recompile with -fPIC 4959 $BuildCmd .= " -fPIC -DPIC"; 4960 $BuildCmd_Test .= " -fPIC -DPIC"; 4961 } 4962 } 4963 elsif($In::Opt{"OS"} eq "macos") 4964 { # using GCC -dynamiclib 4965 if($Lang eq "C") 4966 { 4967 $BuildCmd = $GccPath." -dynamiclib $ObjName.$SrcE -o $ObjName.$LExt"; 4968 $BuildCmd_Test = $GccPath." test.$SrcE $ObjName.$LExt -o test"; 4969 } 4970 else 4971 { # C++ 4972 $BuildCmd = $GccPath." -dynamiclib -x c++ $ObjName.$SrcE -lstdc++ -o $ObjName.$LExt"; 4973 $BuildCmd_Test = $GccPath." -x c++ test.$SrcE $ObjName.$LExt -o test"; 4974 } 4975 } 4976 elsif($In::Opt{"OS"} eq "windows") 4977 { 4978 checkWin32Env(); # to run MS VC++ compiler 4979 my $CL = getCmdPath("cl"); 4980 4981 if(not $CL) { 4982 exitStatus("Not_Found", "can't find \"cl\" compiler"); 4983 } 4984 $BuildCmd = "$CL /LD $ObjName.$SrcE >build_log.txt 2>&1"; 4985 $BuildCmd_Test = "$CL test.$SrcE $ObjName.$LExt"; 4986 } 4987 else 4988 { # default unix-like 4989 if($Lang eq "C") 4990 { 4991 $BuildCmd = $GccPath." -shared $ObjName.$SrcE -o $ObjName.$LExt -g -Og"; 4992 $BuildCmd_Test = $GccPath." test.$SrcE -Wl,$ObjName.$LExt -o test"; 4993 } 4994 else 4995 { # C++ 4996 $BuildCmd = $GccPath." -shared -x c++ $ObjName.$SrcE -lstdc++ -o $ObjName.$LExt -g -Og"; 4997 $BuildCmd_Test = $GccPath." -x c++ test.$SrcE -Wl,$ObjName.$LExt -o test"; 4998 } 4999 5000 if(getArch_GCC(1)=~/\A(arm|x86_64)\Z/i) 5001 { 5002 $BuildCmd .= " -fPIC -DPIC"; 5003 $BuildCmd_Test .= " -fPIC -DPIC"; 5004 } 5005 } 5006 5007 if(my $Opts = getGccOptions(1)) 5008 { # user-defined options 5009 $BuildCmd .= " ".$Opts; 5010 $BuildCmd_Test .= " ".$Opts; 5011 } 5012 5013 my $MkContent = "all:\n\t$BuildCmd\ntest:\n\t$BuildCmd_Test\n"; 5014 if($In::Opt{"OS"} eq "windows") { 5015 $MkContent .= "clean:\n\tdel test $ObjName.so\n"; 5016 } 5017 else { 5018 $MkContent .= "clean:\n\trm test $ObjName.so\n"; 5019 } 5020 writeFile("$Path_v1/Makefile", $MkContent); 5021 writeFile("$Path_v2/Makefile", $MkContent); 5022 system("cd $Path_v1 && $BuildCmd >build-log.txt 2>&1"); 5023 if($?) 5024 { 5025 my $Msg = "can't compile $LibName v.1: \'$Path_v1/build-log.txt\'"; 5026 if(readFile("$Path_v1/build-log.txt")=~/error trying to exec \W+cc1plus\W+/) { 5027 $Msg .= "\nDid you install G++?"; 5028 } 5029 exitStatus("Error", $Msg); 5030 } 5031 system("cd $Path_v2 && $BuildCmd >build-log.txt 2>&1"); 5032 if($?) { 5033 exitStatus("Error", "can't compile $LibName v.2: \'$Path_v2/build-log.txt\'"); 5034 } 5035 5036 # executing the tool 5037 my @Cmd = ("perl", $0, "-l", $LibName); 5038 5039 if($In::Opt{"TestABIDumper"} 5040 and $In::Opt{"OS"} eq "linux") 5041 { 5042 my @Cmd_d1 = ("abi-dumper", $Path_v1."/".$ObjName.".".$LExt, "-o", $LibName."/ABIv1.dump"); 5043 @Cmd_d1 = (@Cmd_d1, "-public-headers", $Path_v1, "-lver", "1.0"); 5044 if($In::Opt{"Debug"}) 5045 { # debug mode 5046 printMsg("INFO", "Executing @Cmd_d1"); 5047 } 5048 system(@Cmd_d1); 5049 printMsg("INFO", ""); 5050 5051 my @Cmd_d2 = ("abi-dumper", $Path_v2."/".$ObjName.".".$LExt, "-o", $LibName."/ABIv2.dump"); 5052 @Cmd_d2 = (@Cmd_d2, "-public-headers", $Path_v2, "-lver", "2.0"); 5053 if($In::Opt{"Debug"}) 5054 { # debug mode 5055 printMsg("INFO", "Executing @Cmd_d2"); 5056 } 5057 system(@Cmd_d2); 5058 printMsg("INFO", ""); 5059 5060 @Cmd = (@Cmd, "-old", $LibName."/ABIv1.dump", "-new", $LibName."/ABIv2.dump"); 5061 } 5062 else 5063 { 5064 @Cmd = (@Cmd, "-old", "$LibName/v1.xml", "-new", "$LibName/v2.xml"); 5065 } 5066 5067 @Cmd = (@Cmd, "-filter", "$LibName/filt.xml"); 5068 5069 if($Lang eq "C") { 5070 @Cmd = (@Cmd, "-cxx-incompatible"); 5071 } 5072 5073 @Cmd = (@Cmd, "-lang", $Lang); 5074 5075 if($In::Opt{"TestDump"}) 5076 { 5077 @Cmd = (@Cmd, "-use-dumps"); 5078 if($In::Opt{"SortDump"}) { 5079 @Cmd = (@Cmd, "-sort"); 5080 } 5081 } 5082 if($In::Opt{"DumpFormat"} and $In::Opt{"DumpFormat"} ne "perl") 5083 { # Perl Data::Dumper is default format 5084 @Cmd = (@Cmd, "-dump-format", $In::Opt{"DumpFormat"}); 5085 } 5086 if($GccPath ne "gcc") { 5087 @Cmd = (@Cmd, "-cross-gcc", $GccPath); 5088 } 5089 if($In::Opt{"Quiet"}) 5090 { # quiet mode 5091 @Cmd = (@Cmd, "-quiet"); 5092 @Cmd = (@Cmd, "-logging-mode", "a"); 5093 } 5094 elsif($In::Opt{"LogMode"} 5095 and $In::Opt{"LogMode"} ne "w") 5096 { # "w" is default 5097 @Cmd = (@Cmd, "-logging-mode", $In::Opt{"LogMode"}); 5098 } 5099 if($In::Opt{"ExtendedCheck"}) 5100 { # extended mode 5101 @Cmd = (@Cmd, "-extended"); 5102 if($Lang eq "C") { 5103 @Cmd = (@Cmd, "-lang", "C"); 5104 } 5105 } 5106 if($In::Opt{"ReportFormat"} 5107 and $In::Opt{"ReportFormat"} ne "html") 5108 { # HTML is default format 5109 @Cmd = (@Cmd, "-report-format", $In::Opt{"ReportFormat"}); 5110 } 5111 if($In::Opt{"CheckHeadersOnly"}) { 5112 @Cmd = (@Cmd, "-headers-only"); 5113 } 5114 if($In::Opt{"OldStyle"}) { 5115 @Cmd = (@Cmd, "-old-style"); 5116 } 5117 5118 if($In::Opt{"DebugMangling"}) { 5119 @Cmd = (@Cmd, "-debug-mangling"); 5120 } 5121 5122 if($In::Opt{"Debug"}) 5123 { # debug mode 5124 @Cmd = (@Cmd, "-debug"); 5125 printMsg("INFO", "Executing @Cmd"); 5126 } 5127 5128 my $RPath = "compat_reports/$LibName/1.0_to_2.0/compat_report.".$In::Opt{"ReportFormat"}; 5129 5130 if(-f $RPath) { 5131 unlink($RPath); 5132 } 5133 5134 system(@Cmd); 5135 5136 my $ECode = $?>>8; 5137 5138 if($ECode!~/\A[016]\Z/ or not -f $RPath) 5139 { # error 5140 exitStatus("Error", "analysis has failed ($ECode)"); 5141 } 5142 5143 my $NProblems = 0; 5144 if($In::Opt{"ReportFormat"} eq "xml") 5145 { 5146 my $Content = readFile($RPath); 5147 # binary 5148 if(my $PSummary = parseTag(\$Content, "problem_summary")) 5149 { 5150 $NProblems += int(parseTag(\$PSummary, "removed_symbols")); 5151 if(my $TProblems = parseTag(\$PSummary, "problems_with_types")) 5152 { 5153 $NProblems += int(parseTag(\$TProblems, "high")); 5154 $NProblems += int(parseTag(\$TProblems, "medium")); 5155 } 5156 if(my $IProblems = parseTag(\$PSummary, "problems_with_symbols")) 5157 { 5158 $NProblems += int(parseTag(\$IProblems, "high")); 5159 $NProblems += int(parseTag(\$IProblems, "medium")); 5160 } 5161 } 5162 # source 5163 if(my $PSummary = parseTag(\$Content, "problem_summary")) 5164 { 5165 $NProblems += int(parseTag(\$PSummary, "removed_symbols")); 5166 if(my $TProblems = parseTag(\$PSummary, "problems_with_types")) 5167 { 5168 $NProblems += int(parseTag(\$TProblems, "high")); 5169 $NProblems += int(parseTag(\$TProblems, "medium")); 5170 } 5171 5172 if(my $IProblems = parseTag(\$PSummary, "problems_with_symbols")) 5173 { 5174 $NProblems += int(parseTag(\$IProblems, "high")); 5175 $NProblems += int(parseTag(\$IProblems, "medium")); 5176 } 5177 } 5178 } 5179 else 5180 { 5181 my $BReport = readAttributes($RPath, 0); 5182 $NProblems += $BReport->{"removed"}; 5183 $NProblems += $BReport->{"type_problems_high"}+$BReport->{"type_problems_medium"}; 5184 $NProblems += $BReport->{"interface_problems_high"}+$BReport->{"interface_problems_medium"}; 5185 5186 my $SReport = readAttributes($RPath, 1); 5187 $NProblems += $SReport->{"removed"}; 5188 $NProblems += $SReport->{"type_problems_high"}+$SReport->{"type_problems_medium"}; 5189 $NProblems += $SReport->{"interface_problems_high"}+$SReport->{"interface_problems_medium"}; 5190 } 5191 5192 if(($LibName eq "libsample_c" and $NProblems>70) 5193 or ($LibName eq "libsample_cpp" and $NProblems>150)) { 5194 printMsg("INFO", "Test result: SUCCESS ($NProblems problems found)\n"); 5195 } 5196 else { 5197 printMsg("ERROR", "Test result: FAILED ($NProblems problems found)\n"); 5198 } 5199} 5200 5201return 1; 5202