clang/test/Analysis/identical-expressions.cpp

   1 // RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core.IdenticalExpr -w -verify %s
   2
   3 /* Only one expected warning per function allowed at the very end. */
   4
   5 int func(void)
   6 {
   7   return 0;
   8 }
   9
  10 int func2(void)
  11 {
  12   return 0;
  13 }
  14
  15 int funcParam(int a)
  16 {
  17   return 0;
  18 }
  19
  20 /* '!=' operator*/
  21
  22 /* '!=' with float */
  23 int checkNotEqualFloatLiteralCompare1(void) {
  24   return (5.14F != 5.14F); // no warning
  25 }
  26
  27 int checkNotEqualFloatLiteralCompare2(void) {
  28   return (6.14F != 7.14F); // no warning
  29 }
  30
  31 int checkNotEqualFloatDeclCompare1(void) {
  32   float f = 7.1F;
  33   float g = 7.1F;
  34   return (f != g); // no warning
  35 }
  36
  37 int checkNotEqualFloatDeclCompare12(void) {
  38   float f = 7.1F;
  39   return (f != f); // no warning
  40 }
  41
  42 int checkNotEqualFloatDeclCompare3(void) {
  43   float f = 7.1F;
  44   return (f != 7.1F); // no warning
  45 }
  46
  47 int checkNotEqualFloatDeclCompare4(void) {
  48   float f = 7.1F;
  49   return (7.1F != f); // no warning
  50 }
  51
  52 int checkNotEqualFloatDeclCompare5(void) {
  53   float f = 7.1F;
  54   int t = 7;
  55   return (t != f); // no warning
  56 }
  57
  58 int checkNotEqualFloatDeclCompare6(void) {
  59   float f = 7.1F;
  60   int t = 7;
  61   return (f != t); // no warning
  62 }
  63
  64
  65
  66 int checkNotEqualCastFloatDeclCompare11(void) {
  67   float f = 7.1F;
  68   return ((int)f != (int)f); // expected-warning {{comparison of identical expressions always evaluates to false}}
  69 }
  70 int checkNotEqualCastFloatDeclCompare12(void) {
  71   float f = 7.1F;
  72   return ((char)f != (int)f); // no warning
  73 }
  74 int checkNotEqualBinaryOpFloatCompare1(void) {
  75   int res;
  76   float f= 3.14F;
  77   res = (f + 3.14F != f + 3.14F);  // no warning
  78   return (0);
  79 }
  80 int checkNotEqualBinaryOpFloatCompare2(void) {
  81   float f = 7.1F;
  82   float g = 7.1F;
  83   return (f + 3.14F != g + 3.14F); // no warning
  84 }
  85 int checkNotEqualBinaryOpFloatCompare3(void) {
  86   int res;
  87   float f= 3.14F;
  88   res = ((int)f + 3.14F != (int)f + 3.14F);  // no warning
  89   return (0);
  90 }
  91 int checkNotEqualBinaryOpFloatCompare4(void) {
  92   int res;
  93   float f= 3.14F;
  94   res = ((int)f + 3.14F != (char)f + 3.14F);  // no warning
  95   return (0);
  96 }
  97
  98 int checkNotEqualNestedBinaryOpFloatCompare1(void) {
  99   int res;
 100   int t= 1;
 101   int u= 2;
 102   float f= 3.14F;
 103   res = (((int)f + (3.14F - u)*t) != ((int)f + (3.14F - u)*t));  // no warning
 104   return (0);
 105 }
 106
 107 int checkNotEqualNestedBinaryOpFloatCompare2(void) {
 108   int res;
 109   int t= 1;
 110   int u= 2;
 111   float f= 3.14F;
 112   res = (((int)f + (u - 3.14F)*t) != ((int)f + (3.14F - u)*t));  // no warning
 113   return (0);
 114 }
 115
 116 int checkNotEqualNestedBinaryOpFloatCompare3(void) {
 117   int res;
 118   int t= 1;
 119   int u= 2;
 120   float f= 3.14F;
 121   res = (((int)f + (u - 3.14F)*t) != ((int)f + (3.14F - u)*(f + t != f + t)));  // no warning
 122   return (0);
 123 }
 124
 125
 126
 127
 128 /* end '!=' with float*/
 129
 130 /* '!=' with int*/
 131
 132 int checkNotEqualIntLiteralCompare1(void) {
 133   return (5 != 5); // expected-warning {{comparison of identical expressions always evaluates to false}}
 134 }
 135
 136 int checkNotEqualIntLiteralCompare2(void) {
 137   return (6 != 7); // no warning
 138 }
 139
 140 int checkNotEqualIntDeclCompare1(void) {
 141   int f = 7;
 142   int g = 7;
 143   return (f != g); // no warning
 144 }
 145
 146 int checkNotEqualIntDeclCompare3(void) {
 147   int f = 7;
 148   return (f != 7); // no warning
 149 }
 150
 151 int checkNotEqualIntDeclCompare4(void) {
 152   int f = 7;
 153   return (7 != f); // no warning
 154 }
 155
 156 int checkNotEqualCastIntDeclCompare11(void) {
 157   int f = 7;
 158   return ((int)f != (int)f); // expected-warning {{comparison of identical expressions always evaluates to false}}
 159 }
 160 int checkNotEqualCastIntDeclCompare12(void) {
 161   int f = 7;
 162   return ((char)f != (int)f); // no warning
 163 }
 164 int checkNotEqualBinaryOpIntCompare1(void) {
 165   int res;
 166   int t= 1;
 167   int u= 2;
 168   int f= 4;
 169   res = (f + 4 != f + 4);  // expected-warning {{comparison of identical expressions always evaluates to false}}
 170   return (0);
 171 }
 172 int checkNotEqualBinaryOpIntCompare2(void) {
 173   int f = 7;
 174   int g = 7;
 175   return (f + 4 != g + 4); // no warning
 176 }
 177
 178
 179 int checkNotEqualBinaryOpIntCompare3(void) {
 180   int res;
 181   int t= 1;
 182   int u= 2;
 183   int f= 4;
 184   res = ((int)f + 4 != (int)f + 4);  // expected-warning {{comparison of identical expressions always evaluates to false}}
 185   return (0);
 186 }
 187 int checkNotEqualBinaryOpIntCompare4(void) {
 188   int res;
 189   int t= 1;
 190   int u= 2;
 191   int f= 4;
 192   res = ((int)f + 4 != (char)f + 4);  // no warning
 193   return (0);
 194 }
 195 int checkNotEqualBinaryOpIntCompare5(void) {
 196   int res;
 197   int t= 1;
 198   int u= 2;
 199   res = (u + t != u + t);  // expected-warning {{comparison of identical expressions always evaluates to false}}
 200   return (0);
 201 }
 202
 203 int checkNotEqualNestedBinaryOpIntCompare1(void) {
 204   int res;
 205   int t= 1;
 206   int u= 2;
 207   int f= 3;
 208   res = (((int)f + (3 - u)*t) != ((int)f + (3 - u)*t));  // expected-warning {{comparison of identical expressions always evaluates to false}}
 209   return (0);
 210 }
 211
 212 int checkNotEqualNestedBinaryOpIntCompare2(void) {
 213   int res;
 214   int t= 1;
 215   int u= 2;
 216   int f= 3;
 217   res = (((int)f + (u - 3)*t) != ((int)f + (3 - u)*t));  // no warning
 218   return (0);
 219 }
 220
 221 int checkNotEqualNestedBinaryOpIntCompare3(void) {
 222   int res;
 223   int t= 1;
 224   int u= 2;
 225   int f= 3;
 226   res = (((int)f + (u - 3)*t) != ((int)f + (3 - u)*(t + 1 != t + 1)));  // expected-warning {{comparison of identical expressions always evaluates to false}}
 227   return (0);
 228 }
 229
 230 /*   end '!=' int          */
 231
 232
 233
 234 /* '!=' with int pointer */
 235
 236 int checkNotEqualIntPointerLiteralCompare1(void) {
 237   int* p = 0;
 238   return (p != 0); // no warning
 239 }
 240
 241 int checkNotEqualIntPointerLiteralCompare2(void) {
 242   return (6 != 7); // no warning
 243 }
 244
 245 int checkNotEqualIntPointerDeclCompare1(void) {
 246   int k = 3;
 247   int* f = &k;
 248   int* g = &k;
 249   return (f != g); // no warning
 250 }
 251
 252 int checkNotEqualCastIntPointerDeclCompare11(void) {
 253   int k = 7;
 254   int* f = &k;
 255   return ((int*)f != (int*)f); // expected-warning {{comparison of identical expressions always evaluates to false}}
 256 }
 257 int checkNotEqualCastIntPointerDeclCompare12(void) {
 258   int k = 7;
 259   int* f = &k;
 260   return ((int*)((char*)f) != (int*)f); // no warning
 261 }
 262 int checkNotEqualBinaryOpIntPointerCompare1(void) {
 263   int k = 7;
 264   int res;
 265   int* f= &k;
 266   res = (f + 4 != f + 4);  // expected-warning {{comparison of identical expressions always evaluates to false}}
 267   return (0);
 268 }
 269 int checkNotEqualBinaryOpIntPointerCompare2(void) {
 270   int k = 7;
 271   int* f = &k;
 272   int* g = &k;
 273   return (f + 4 != g + 4); // no warning
 274 }
 275
 276
 277 int checkNotEqualBinaryOpIntPointerCompare3(void) {
 278   int k = 7;
 279   int res;
 280   int* f= &k;
 281   res = ((int*)f + 4 != (int*)f + 4);  // expected-warning {{comparison of identical expressions always evaluates to false}}
 282   return (0);
 283 }
 284 int checkNotEqualBinaryOpIntPointerCompare4(void) {
 285   int k = 7;
 286   int res;
 287   int* f= &k;
 288   res = ((int*)f + 4 != (int*)((char*)f) + 4);  // no warning
 289   return (0);
 290 }
 291
 292 int checkNotEqualNestedBinaryOpIntPointerCompare1(void) {
 293   int res;
 294   int k = 7;
 295   int t= 1;
 296   int* u= &k+2;
 297   int* f= &k+3;
 298   res = ((f + (3)*t) != (f + (3)*t));  // expected-warning {{comparison of identical expressions always evaluates to false}}
 299   return (0);
 300 }
 301
 302 int checkNotEqualNestedBinaryOpIntPointerCompare2(void) {
 303   int res;
 304   int k = 7;
 305   int t= 1;
 306   int* u= &k+2;
 307   int* f= &k+3;
 308   res = (((3)*t + f) != (f + (3)*t));  // no warning
 309   return (0);
 310 }
 311 /*   end '!=' int*          */
 312
 313 /* '!=' with function*/
 314
 315 int checkNotEqualSameFunction() {
 316   unsigned a = 0;
 317   unsigned b = 1;
 318   int res = (a+func() != a+func());  // no warning
 319   return (0);
 320 }
 321
 322 int checkNotEqualDifferentFunction() {
 323   unsigned a = 0;
 324   unsigned b = 1;
 325   int res = (a+func() != a+func2());  // no warning
 326   return (0);
 327 }
 328
 329 int checkNotEqualSameFunctionSameParam() {
 330   unsigned a = 0;
 331   unsigned b = 1;
 332   int res = (a+funcParam(a) != a+funcParam(a));  // no warning
 333   return (0);
 334 }
 335
 336 int checkNotEqualSameFunctionDifferentParam() {
 337   unsigned a = 0;
 338   unsigned b = 1;
 339   int res = (a+funcParam(a) != a+funcParam(b));  // no warning
 340   return (0);
 341 }
 342
 343 /*   end '!=' with function*/
 344
 345 /*   end '!=' */
 346
 347
 348
 349 /* EQ operator           */
 350
 351 int checkEqualIntPointerDeclCompare(void) {
 352   int k = 3;
 353   int* f = &k;
 354   int* g = &k;
 355   return (f == g); // no warning
 356 }
 357
 358 int checkEqualIntPointerDeclCompare0(void) {
 359   int k = 3;
 360   int* f = &k;
 361   return (f+1 == f+1); // expected-warning {{comparison of identical expressions always evaluates to true}}
 362 }
 363
 364 /* EQ with float*/
 365
 366 int checkEqualFloatLiteralCompare1(void) {
 367   return (5.14F == 5.14F); // no warning
 368 }
 369
 370 int checkEqualFloatLiteralCompare2(void) {
 371   return (6.14F == 7.14F); // no warning
 372 }
 373
 374 int checkEqualFloatDeclCompare1(void) {
 375   float f = 7.1F;
 376   float g = 7.1F;
 377   return (f == g); // no warning
 378 }
 379
 380 int checkEqualFloatDeclCompare12(void) {
 381   float f = 7.1F;
 382   return (f == f); // no warning
 383 }
 384
 385
 386 int checkEqualFloatDeclCompare3(void) {
 387   float f = 7.1F;
 388   return (f == 7.1F); // no warning
 389 }
 390
 391 int checkEqualFloatDeclCompare4(void) {
 392   float f = 7.1F;
 393   return (7.1F == f); // no warning
 394 }
 395
 396 int checkEqualFloatDeclCompare5(void) {
 397   float f = 7.1F;
 398   int t = 7;
 399   return (t == f); // no warning
 400 }
 401
 402 int checkEqualFloatDeclCompare6(void) {
 403   float f = 7.1F;
 404   int t = 7;
 405   return (f == t); // no warning
 406 }
 407
 408
 409
 410
 411 int checkEqualCastFloatDeclCompare11(void) {
 412   float f = 7.1F;
 413   return ((int)f == (int)f); // expected-warning {{comparison of identical expressions always evaluates to true}}
 414 }
 415 int checkEqualCastFloatDeclCompare12(void) {
 416   float f = 7.1F;
 417   return ((char)f == (int)f); // no warning
 418 }
 419 int checkEqualBinaryOpFloatCompare1(void) {
 420   int res;
 421   float f= 3.14F;
 422   res = (f + 3.14F == f + 3.14F);  // no warning
 423   return (0);
 424 }
 425 int checkEqualBinaryOpFloatCompare2(void) {
 426   float f = 7.1F;
 427   float g = 7.1F;
 428   return (f + 3.14F == g + 3.14F); // no warning
 429 }
 430 int checkEqualBinaryOpFloatCompare3(void) {
 431   int res;
 432   float f= 3.14F;
 433   res = ((int)f + 3.14F == (int)f + 3.14F);  // no warning
 434   return (0);
 435 }
 436 int checkEqualBinaryOpFloatCompare4(void) {
 437   int res;
 438   float f= 3.14F;
 439   res = ((int)f + 3.14F == (char)f + 3.14F);  // no warning
 440   return (0);
 441 }
 442
 443 int checkEqualNestedBinaryOpFloatCompare1(void) {
 444   int res;
 445   int t= 1;
 446   int u= 2;
 447   float f= 3.14F;
 448   res = (((int)f + (3.14F - u)*t) == ((int)f + (3.14F - u)*t));  // no warning
 449   return (0);
 450 }
 451
 452 int checkEqualNestedBinaryOpFloatCompare2(void) {
 453   int res;
 454   int t= 1;
 455   int u= 2;
 456   float f= 3.14F;
 457   res = (((int)f + (u - 3.14F)*t) == ((int)f + (3.14F - u)*t));  // no warning
 458   return (0);
 459 }
 460
 461 int checkEqualNestedBinaryOpFloatCompare3(void) {
 462   int res;
 463   int t= 1;
 464   int u= 2;
 465   float f= 3.14F;
 466   res = (((int)f + (u - 3.14F)*t) == ((int)f + (3.14F - u)*(f + t == f + t)));  // no warning
 467   return (0);
 468 }
 469
 470
 471
 472
 473
 474 /* Equal with int*/
 475
 476 int checkEqualIntLiteralCompare1(void) {
 477   return (5 == 5); // expected-warning {{comparison of identical expressions always evaluates to true}}
 478 }
 479
 480 int checkEqualIntLiteralCompare2(void) {
 481   return (6 == 7); // no warning
 482 }
 483
 484 int checkEqualIntDeclCompare1(void) {
 485   int f = 7;
 486   int g = 7;
 487   return (f == g); // no warning
 488 }
 489
 490 int checkEqualCastIntDeclCompare11(void) {
 491   int f = 7;
 492   return ((int)f == (int)f); // expected-warning {{comparison of identical expressions always evaluates to true}}
 493 }
 494 int checkEqualCastIntDeclCompare12(void) {
 495   int f = 7;
 496   return ((char)f == (int)f); // no warning
 497 }
 498
 499 int checkEqualIntDeclCompare3(void) {
 500   int f = 7;
 501   return (f == 7); // no warning
 502 }
 503
 504 int checkEqualIntDeclCompare4(void) {
 505   int f = 7;
 506   return (7 == f); // no warning
 507 }
 508
 509 int checkEqualBinaryOpIntCompare1(void) {
 510   int res;
 511   int t= 1;
 512   int u= 2;
 513   int f= 4;
 514   res = (f + 4 == f + 4);  // expected-warning {{comparison of identical expressions always evaluates to true}}
 515   return (0);
 516 }
 517 int checkEqualBinaryOpIntCompare2(void) {
 518   int f = 7;
 519   int g = 7;
 520   return (f + 4 == g + 4); // no warning
 521 }
 522
 523
 524 int checkEqualBinaryOpIntCompare3(void) {
 525   int res;
 526   int t= 1;
 527   int u= 2;
 528   int f= 4;
 529   res = ((int)f + 4 == (int)f + 4);  // expected-warning {{comparison of identical expressions always evaluates to true}}
 530   return (0);
 531
 532 }
 533 int checkEqualBinaryOpIntCompare4(void) {
 534   int res;
 535   int t= 1;
 536   int u= 2;
 537   int f= 4;
 538   res = ((int)f + 4 == (char)f + 4);  // no warning
 539   return (0);
 540 }
 541 int checkEqualBinaryOpIntCompare5(void) {
 542   int res;
 543   int t= 1;
 544   int u= 2;
 545   res = (u + t == u + t);  // expected-warning {{comparison of identical expressions always evaluates to true}}
 546   return (0);
 547 }
 548
 549 int checkEqualNestedBinaryOpIntCompare1(void) {
 550   int res;
 551   int t= 1;
 552   int u= 2;
 553   int f= 3;
 554   res = (((int)f + (3 - u)*t) == ((int)f + (3 - u)*t));  // expected-warning {{comparison of identical expressions always evaluates to true}}
 555   return (0);
 556 }
 557
 558 int checkEqualNestedBinaryOpIntCompare2(void) {
 559   int res;
 560   int t= 1;
 561   int u= 2;
 562   int f= 3;
 563   res = (((int)f + (u - 3)*t) == ((int)f + (3 - u)*t));  // no warning
 564   return (0);
 565 }
 566
 567 int checkEqualNestedBinaryOpIntCompare3(void) {
 568   int res;
 569   int t= 1;
 570   int u= 2;
 571   int f= 3;
 572   res = (((int)f + (u - 3)*t) == ((int)f + (3 - u)*(t + 1 == t + 1)));  // expected-warning {{comparison of identical expressions always evaluates to true}}
 573   return (0);
 574 }
 575
 576 /* '==' with function*/
 577
 578 int checkEqualSameFunction() {
 579   unsigned a = 0;
 580   unsigned b = 1;
 581   int res = (a+func() == a+func());  // no warning
 582   return (0);
 583 }
 584
 585 int checkEqualDifferentFunction() {
 586   unsigned a = 0;
 587   unsigned b = 1;
 588   int res = (a+func() == a+func2());  // no warning
 589   return (0);
 590 }
 591
 592 int checkEqualSameFunctionSameParam() {
 593   unsigned a = 0;
 594   unsigned b = 1;
 595   int res = (a+funcParam(a) == a+funcParam(a));  // no warning
 596   return (0);
 597 }
 598
 599 int checkEqualSameFunctionDifferentParam() {
 600   unsigned a = 0;
 601   unsigned b = 1;
 602   int res = (a+funcParam(a) == a+funcParam(b));  // no warning
 603   return (0);
 604 }
 605
 606 /*   end '==' with function*/
 607
 608 /*   end EQ int          */
 609
 610 /* end EQ */
 611
 612
 613 /*  LT */
 614
 615 /*  LT with float */
 616
 617 int checkLessThanFloatLiteralCompare1(void) {
 618   return (5.14F < 5.14F); // expected-warning {{comparison of identical expressions always evaluates to false}}
 619 }
 620
 621 int checkLessThanFloatLiteralCompare2(void) {
 622   return (6.14F < 7.14F); // no warning
 623 }
 624
 625 int checkLessThanFloatDeclCompare1(void) {
 626   float f = 7.1F;
 627   float g = 7.1F;
 628   return (f < g); // no warning
 629 }
 630
 631 int checkLessThanFloatDeclCompare12(void) {
 632   float f = 7.1F;
 633   return (f < f); // expected-warning {{comparison of identical expressions always evaluates to false}}
 634 }
 635
 636 int checkLessThanFloatDeclCompare3(void) {
 637   float f = 7.1F;
 638   return (f < 7.1F); // no warning
 639 }
 640
 641 int checkLessThanFloatDeclCompare4(void) {
 642   float f = 7.1F;
 643   return (7.1F < f); // no warning
 644 }
 645
 646 int checkLessThanFloatDeclCompare5(void) {
 647   float f = 7.1F;
 648   int t = 7;
 649   return (t < f); // no warning
 650 }
 651
 652 int checkLessThanFloatDeclCompare6(void) {
 653   float f = 7.1F;
 654   int t = 7;
 655   return (f < t); // no warning
 656 }
 657
 658
 659 int checkLessThanCastFloatDeclCompare11(void) {
 660   float f = 7.1F;
 661   return ((int)f < (int)f); // expected-warning {{comparison of identical expressions always evaluates to false}}
 662 }
 663 int checkLessThanCastFloatDeclCompare12(void) {
 664   float f = 7.1F;
 665   return ((char)f < (int)f); // no warning
 666 }
 667 int checkLessThanBinaryOpFloatCompare1(void) {
 668   int res;
 669   float f= 3.14F;
 670   res = (f + 3.14F < f + 3.14F);  // no warning
 671   return (0);
 672 }
 673 int checkLessThanBinaryOpFloatCompare2(void) {
 674   float f = 7.1F;
 675   float g = 7.1F;
 676   return (f + 3.14F < g + 3.14F); // no warning
 677 }
 678 int checkLessThanBinaryOpFloatCompare3(void) {
 679   int res;
 680   float f= 3.14F;
 681   res = ((int)f + 3.14F < (int)f + 3.14F);  // no warning
 682   return (0);
 683 }
 684 int checkLessThanBinaryOpFloatCompare4(void) {
 685   int res;
 686   float f= 3.14F;
 687   res = ((int)f + 3.14F < (char)f + 3.14F);  // no warning
 688   return (0);
 689 }
 690
 691 int checkLessThanNestedBinaryOpFloatCompare1(void) {
 692   int res;
 693   int t= 1;
 694   int u= 2;
 695   float f= 3.14F;
 696   res = (((int)f + (3.14F - u)*t) < ((int)f + (3.14F - u)*t));  // no warning
 697   return (0);
 698 }
 699
 700 int checkLessThanNestedBinaryOpFloatCompare2(void) {
 701   int res;
 702   int t= 1;
 703   int u= 2;
 704   float f= 3.14F;
 705   res = (((int)f + (u - 3.14F)*t) < ((int)f + (3.14F - u)*t));  // no warning
 706   return (0);
 707 }
 708
 709 int checkLessThanNestedBinaryOpFloatCompare3(void) {
 710   int res;
 711   int t= 1;
 712   int u= 2;
 713   float f= 3.14F;
 714   res = (((int)f + (u - 3.14F)*t) < ((int)f + (3.14F - u)*(f + t < f + t)));  // no warning
 715   return (0);
 716 }
 717
 718 /*  end LT with float */
 719
 720 /*  LT with int */
 721
 722
 723 int checkLessThanIntLiteralCompare1(void) {
 724   return (5 < 5); // expected-warning {{comparison of identical expressions always evaluates to false}}
 725 }
 726
 727 int checkLessThanIntLiteralCompare2(void) {
 728   return (6 < 7); // no warning
 729 }
 730
 731 int checkLessThanIntDeclCompare1(void) {
 732   int f = 7;
 733   int g = 7;
 734   return (f < g); // no warning
 735 }
 736
 737 int checkLessThanIntDeclCompare3(void) {
 738   int f = 7;
 739   return (f < 7); // no warning
 740 }
 741
 742 int checkLessThanIntDeclCompare4(void) {
 743   int f = 7;
 744   return (7 < f); // no warning
 745 }
 746
 747 int checkLessThanIntDeclCompare5(void) {
 748   int f = 7;
 749   int t = 7;
 750   return (t < f); // no warning
 751 }
 752
 753 int checkLessThanIntDeclCompare6(void) {
 754   int f = 7;
 755   int t = 7;
 756   return (f < t); // no warning
 757 }
 758
 759 int checkLessThanCastIntDeclCompare11(void) {
 760   int f = 7;
 761   return ((int)f < (int)f); // expected-warning {{comparison of identical expressions always evaluates to false}}
 762 }
 763 int checkLessThanCastIntDeclCompare12(void) {
 764   int f = 7;
 765   return ((char)f < (int)f); // no warning
 766 }
 767 int checkLessThanBinaryOpIntCompare1(void) {
 768   int res;
 769   int f= 3;
 770   res = (f + 3 < f + 3);  // expected-warning {{comparison of identical expressions always evaluates to false}}
 771   return (0);
 772 }
 773 int checkLessThanBinaryOpIntCompare2(void) {
 774   int f = 7;
 775   int g = 7;
 776   return (f + 3 < g + 3); // no warning
 777 }
 778 int checkLessThanBinaryOpIntCompare3(void) {
 779   int res;
 780   int f= 3;
 781   res = ((int)f + 3 < (int)f + 3);  // expected-warning {{comparison of identical expressions always evaluates to false}}
 782   return (0);
 783 }
 784 int checkLessThanBinaryOpIntCompare4(void) {
 785   int res;
 786   int f= 3;
 787   res = ((int)f + 3 < (char)f + 3);  // no warning
 788   return (0);
 789 }
 790
 791 int checkLessThanNestedBinaryOpIntCompare1(void) {
 792   int res;
 793   int t= 1;
 794   int u= 2;
 795   int f= 3;
 796   res = (((int)f + (3 - u)*t) < ((int)f + (3 - u)*t));  // expected-warning {{comparison of identical expressions always evaluates to false}}
 797   return (0);
 798 }
 799
 800 int checkLessThanNestedBinaryOpIntCompare2(void) {
 801   int res;
 802   int t= 1;
 803   int u= 2;
 804   int f= 3;
 805   res = (((int)f + (u - 3)*t) < ((int)f + (3 - u)*t));  // no warning
 806   return (0);
 807 }
 808
 809 int checkLessThanNestedBinaryOpIntCompare3(void) {
 810   int res;
 811   int t= 1;
 812   int u= 2;
 813   int f= 3;
 814   res = (((int)f + (u - 3)*t) < ((int)f + (3 - u)*(t + u < t + u)));  // expected-warning {{comparison of identical expressions always evaluates to false}}
 815   return (0);
 816 }
 817
 818 /* end LT with int */
 819
 820 /* end LT */
 821
 822
 823 /* GT */
 824
 825 /* GT with float */
 826
 827 int checkGreaterThanFloatLiteralCompare1(void) {
 828   return (5.14F > 5.14F); // expected-warning {{comparison of identical expressions always evaluates to false}}
 829 }
 830
 831 int checkGreaterThanFloatLiteralCompare2(void) {
 832   return (6.14F > 7.14F); // no warning
 833 }
 834
 835 int checkGreaterThanFloatDeclCompare1(void) {
 836   float f = 7.1F;
 837   float g = 7.1F;
 838
 839   return (f > g); // no warning
 840 }
 841
 842 int checkGreaterThanFloatDeclCompare12(void) {
 843   float f = 7.1F;
 844   return (f > f); // expected-warning {{comparison of identical expressions always evaluates to false}}
 845 }
 846
 847
 848 int checkGreaterThanFloatDeclCompare3(void) {
 849   float f = 7.1F;
 850   return (f > 7.1F); // no warning
 851 }
 852
 853 int checkGreaterThanFloatDeclCompare4(void) {
 854   float f = 7.1F;
 855   return (7.1F > f); // no warning
 856 }
 857
 858 int checkGreaterThanFloatDeclCompare5(void) {
 859   float f = 7.1F;
 860   int t = 7;
 861   return (t > f); // no warning
 862 }
 863
 864 int checkGreaterThanFloatDeclCompare6(void) {
 865   float f = 7.1F;
 866   int t = 7;
 867   return (f > t); // no warning
 868 }
 869
 870 int checkGreaterThanCastFloatDeclCompare11(void) {
 871   float f = 7.1F;
 872   return ((int)f > (int)f); // expected-warning {{comparison of identical expressions always evaluates to false}}
 873 }
 874 int checkGreaterThanCastFloatDeclCompare12(void) {
 875   float f = 7.1F;
 876   return ((char)f > (int)f); // no warning
 877 }
 878 int checkGreaterThanBinaryOpFloatCompare1(void) {
 879   int res;
 880   float f= 3.14F;
 881   res = (f + 3.14F > f + 3.14F);  // no warning
 882   return (0);
 883 }
 884 int checkGreaterThanBinaryOpFloatCompare2(void) {
 885   float f = 7.1F;
 886   float g = 7.1F;
 887   return (f + 3.14F > g + 3.14F); // no warning
 888 }
 889 int checkGreaterThanBinaryOpFloatCompare3(void) {
 890   int res;
 891   float f= 3.14F;
 892   res = ((int)f + 3.14F > (int)f + 3.14F);  // no warning
 893   return (0);
 894 }
 895 int checkGreaterThanBinaryOpFloatCompare4(void) {
 896   int res;
 897   float f= 3.14F;
 898   res = ((int)f + 3.14F > (char)f + 3.14F);  // no warning
 899   return (0);
 900 }
 901
 902 int checkGreaterThanNestedBinaryOpFloatCompare1(void) {
 903   int res;
 904   int t= 1;
 905   int u= 2;
 906   float f= 3.14F;
 907   res = (((int)f + (3.14F - u)*t) > ((int)f + (3.14F - u)*t));  // no warning
 908   return (0);
 909 }
 910
 911 int checkGreaterThanNestedBinaryOpFloatCompare2(void) {
 912   int res;
 913   int t= 1;
 914   int u= 2;
 915   float f= 3.14F;
 916   res = (((int)f + (u - 3.14F)*t) > ((int)f + (3.14F - u)*t));  // no warning
 917   return (0);
 918 }
 919
 920 int checkGreaterThanNestedBinaryOpFloatCompare3(void) {
 921   int res;
 922   int t= 1;
 923   int u= 2;
 924   float f= 3.14F;
 925   res = (((int)f + (u - 3.14F)*t) > ((int)f + (3.14F - u)*(f + t > f + t)));  // no warning
 926   return (0);
 927 }
 928
 929 /*  end GT with float */
 930
 931 /*  GT with int */
 932
 933
 934 int checkGreaterThanIntLiteralCompare1(void) {
 935   return (5 > 5); // expected-warning {{comparison of identical expressions always evaluates to false}}
 936 }
 937
 938 int checkGreaterThanIntLiteralCompare2(void) {
 939   return (6 > 7); // no warning
 940 }
 941
 942 int checkGreaterThanIntDeclCompare1(void) {
 943   int f = 7;
 944   int g = 7;
 945
 946   return (f > g); // no warning
 947 }
 948
 949 int checkGreaterThanIntDeclCompare3(void) {
 950   int f = 7;
 951   return (f > 7); // no warning
 952 }
 953
 954 int checkGreaterThanIntDeclCompare4(void) {
 955   int f = 7;
 956   return (7 > f); // no warning
 957 }
 958
 959 int checkGreaterThanCastIntDeclCompare11(void) {
 960   int f = 7;
 961   return ((int)f > (int)f); // expected-warning {{comparison of identical expressions always evaluates to false}}
 962 }
 963 int checkGreaterThanCastIntDeclCompare12(void) {
 964   int f = 7;
 965   return ((char)f > (int)f); // no warning
 966 }
 967 int checkGreaterThanBinaryOpIntCompare1(void) {
 968   int res;
 969   int f= 3;
 970   res = (f + 3 > f + 3);  // expected-warning {{comparison of identical expressions always evaluates to false}}
 971   return (0);
 972 }
 973 int checkGreaterThanBinaryOpIntCompare2(void) {
 974   int f = 7;
 975   int g = 7;
 976   return (f + 3 > g + 3); // no warning
 977 }
 978 int checkGreaterThanBinaryOpIntCompare3(void) {
 979   int res;
 980   int f= 3;
 981   res = ((int)f + 3 > (int)f + 3);  // expected-warning {{comparison of identical expressions always evaluates to false}}
 982   return (0);
 983 }
 984 int checkGreaterThanBinaryOpIntCompare4(void) {
 985   int res;
 986   int f= 3;
 987   res = ((int)f + 3 > (char)f + 3);  // no warning
 988   return (0);
 989 }
 990
 991 int checkGreaterThanNestedBinaryOpIntCompare1(void) {
 992   int res;
 993   int t= 1;
 994   int u= 2;
 995   int f= 3;
 996   res = (((int)f + (3 - u)*t) > ((int)f + (3 - u)*t));  // expected-warning {{comparison of identical expressions always evaluates to false}}
 997   return (0);
 998 }
 999
1000 int checkGreaterThanNestedBinaryOpIntCompare2(void) {
1001   int res;
1002   int t= 1;
1003   int u= 2;
1004   int f= 3;
1005   res = (((int)f + (u - 3)*t) > ((int)f + (3 - u)*t));  // no warning
1006   return (0);
1007 }
1008
1009 int checkGreaterThanNestedBinaryOpIntCompare3(void) {
1010   int res;
1011   int t= 1;
1012   int u= 2;
1013   int f= 3;
1014   res = (((int)f + (u - 3)*t) > ((int)f + (3 - u)*(t + u > t + u)));  // expected-warning {{comparison of identical expressions always evaluates to false}}
1015   return (0);
1016 }
1017
1018 /* end GT with int */
1019
1020 /* end GT */
1021
1022
1023 /* Checking use of identical expressions in conditional operator*/
1024
1025 unsigned test_unsigned(unsigned a) {
1026   unsigned b = 1;
1027   a = a > 5 ? b : b; // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1028   return a;
1029 }
1030
1031 void test_signed() {
1032   int a = 0;
1033   a = a > 5 ? a : a; // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1034 }
1035
1036 void test_bool(bool a) {
1037   a = a > 0 ? a : a; // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1038 }
1039
1040 void test_float() {
1041   float a = 0;
1042   float b = 0;
1043   a = a > 5 ? a : a; // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1044 }
1045
1046 const char *test_string() {
1047   float a = 0;
1048   return a > 5 ? "abc" : "abc"; // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1049 }
1050
1051 void test_unsigned_expr() {
1052   unsigned a = 0;
1053   unsigned b = 0;
1054   a = a > 5 ? a+b : a+b; // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1055 }
1056
1057 void test_signed_expr() {
1058   int a = 0;
1059   int b = 1;
1060   a = a > 5 ? a+b : a+b; // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1061 }
1062
1063 void test_bool_expr(bool a) {
1064   bool b = 0;
1065   a = a > 0 ? a&&b : a&&b; // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1066 }
1067
1068 void test_unsigned_expr_negative() {
1069   unsigned a = 0;
1070   unsigned b = 0;
1071   a = a > 5 ? a+b : b+a; // no warning
1072 }
1073
1074 void test_signed_expr_negative() {
1075   int a = 0;
1076   int b = 1;
1077   a = a > 5 ? b+a : a+b; // no warning
1078 }
1079
1080 void test_bool_expr_negative(bool a) {
1081   bool b = 0;
1082   a = a > 0 ? a&&b : b&&a; // no warning
1083 }
1084
1085 void test_float_expr_positive() {
1086   float a = 0;
1087   float b = 0;
1088   a = a > 5 ? a+b : a+b; // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1089 }
1090
1091 void test_expr_positive_func() {
1092   unsigned a = 0;
1093   unsigned b = 1;
1094   a = a > 5 ? a+func() : a+func(); // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1095 }
1096
1097 void test_expr_negative_func() {
1098   unsigned a = 0;
1099   unsigned b = 1;
1100   a = a > 5 ? a+func() : a+func2(); // no warning
1101 }
1102
1103 void test_expr_positive_funcParam() {
1104   unsigned a = 0;
1105   unsigned b = 1;
1106   a = a > 5 ? a+funcParam(b) : a+funcParam(b); // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1107 }
1108
1109 void test_expr_negative_funcParam() {
1110   unsigned a = 0;
1111   unsigned b = 1;
1112   a = a > 5 ? a+funcParam(a) : a+funcParam(b); // no warning
1113 }
1114
1115 void test_expr_positive_inc() {
1116   unsigned a = 0;
1117   unsigned b = 1;
1118   a = a > 5 ? a++ : a++; // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1119 }
1120
1121 void test_expr_negative_inc() {
1122   unsigned a = 0;
1123   unsigned b = 1;
1124   a = a > 5 ? a++ : b++; // no warning
1125 }
1126
1127 void test_expr_positive_assign() {
1128   unsigned a = 0;
1129   unsigned b = 1;
1130   a = a > 5 ? a=1 : a=1;  // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1131 }
1132
1133 void test_expr_negative_assign() {
1134   unsigned a = 0;
1135   unsigned b = 1;
1136   a = a > 5 ? a=1 : a=2; // no warning
1137 }
1138
1139 void test_signed_nested_expr() {
1140   int a = 0;
1141   int b = 1;
1142   int c = 3;
1143   a = a > 5 ? a+b+(c+a)*(a + b*(c+a)) : a+b+(c+a)*(a + b*(c+a)); // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1144 }
1145
1146 void test_signed_nested_expr_negative() {
1147   int a = 0;
1148   int b = 1;
1149   int c = 3;
1150   a = a > 5 ? a+b+(c+a)*(a + b*(c+a)) : a+b+(c+a)*(a + b*(a+c)); // no warning
1151 }
1152
1153 void test_signed_nested_cond_expr_negative() {
1154   int a = 0;
1155   int b = 1;
1156   int c = 3;
1157   a = a > 5 ? (b > 5 ? 1 : 4) : (b > 5 ? 2 : 4); // no warning
1158 }
1159
1160 void test_signed_nested_cond_expr() {
1161   int a = 0;
1162   int b = 1;
1163   int c = 3;
1164   a = a > 5 ? (b > 5 ? 1 : 4) : (b > 5 ? 4 : 4); // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1165 }
1166
1167 void test_identical_branches1(bool b) {
1168   int i = 0;
1169   if (b) { // expected-warning {{true and false branches are identical}}
1170     ++i;
1171   } else {
1172     ++i;
1173   }
1174 }
1175
1176 void test_identical_branches2(bool b) {
1177   int i = 0;
1178   if (b) { // expected-warning {{true and false branches are identical}}
1179     ++i;
1180   } else
1181     ++i;
1182 }
1183
1184 void test_identical_branches3(bool b) {
1185   int i = 0;
1186   if (b) { // no warning
1187     ++i;
1188   } else {
1189     i++;
1190   }
1191 }
1192
1193 void test_identical_branches4(bool b) {
1194   int i = 0;
1195   if (b) { // expected-warning {{true and false branches are identical}}
1196   } else {
1197   }
1198 }
1199
1200 void test_identical_branches_break(bool b) {
1201   while (true) {
1202     if (b) // expected-warning {{true and false branches are identical}}
1203       break;
1204     else
1205       break;
1206   }
1207 }
1208
1209 void test_identical_branches_continue(bool b) {
1210   while (true) {
1211     if (b) // expected-warning {{true and false branches are identical}}
1212       continue;
1213     else
1214       continue;
1215   }
1216 }
1217
1218 void test_identical_branches_func(bool b) {
1219   if (b) // expected-warning {{true and false branches are identical}}
1220     func();
1221   else
1222     func();
1223 }
1224
1225 void test_identical_branches_func_arguments(bool b) {
1226   if (b) // no-warning
1227     funcParam(1);
1228   else
1229     funcParam(2);
1230 }
1231
1232 void test_identical_branches_cast1(bool b) {
1233   long v = -7;
1234   if (b) // no-warning
1235     v = (signed int) v;
1236   else
1237     v = (unsigned int) v;
1238 }
1239
1240 void test_identical_branches_cast2(bool b) {
1241   long v = -7;
1242   if (b) // expected-warning {{true and false branches are identical}}
1243     v = (signed int) v;
1244   else
1245     v = (signed int) v;
1246 }
1247
1248 int test_identical_branches_return_int(bool b) {
1249   int i = 0;
1250   if (b) { // expected-warning {{true and false branches are identical}}
1251     i++;
1252     return i;
1253   } else {
1254     i++;
1255     return i;
1256   }
1257 }
1258
1259 int test_identical_branches_return_func(bool b) {
1260   if (b) { // expected-warning {{true and false branches are identical}}
1261     return func();
1262   } else {
1263     return func();
1264   }
1265 }
1266
1267 void test_identical_branches_for(bool b) {
1268   int i;
1269   int j;
1270   if (b) { // expected-warning {{true and false branches are identical}}
1271     for (i = 0, j = 0; i < 10; i++)
1272       j += 4;
1273   } else {
1274     for (i = 0, j = 0; i < 10; i++)
1275       j += 4;
1276   }
1277 }
1278
1279 void test_identical_branches_while(bool b) {
1280   int i = 10;
1281   if (b) { // expected-warning {{true and false branches are identical}}
1282     while (func())
1283       i--;
1284   } else {
1285     while (func())
1286       i--;
1287   }
1288 }
1289
1290 void test_identical_branches_while_2(bool b) {
1291   int i = 10;
1292   if (b) { // no-warning
1293     while (func())
1294       i--;
1295   } else {
1296     while (func())
1297       i++;
1298   }
1299 }
1300
1301 void test_identical_branches_do_while(bool b) {
1302   int i = 10;
1303   if (b) { // expected-warning {{true and false branches are identical}}
1304     do {
1305       i--;
1306     } while (func());
1307   } else {
1308     do {
1309       i--;
1310     } while (func());
1311   }
1312 }
1313
1314 void test_identical_branches_if(bool b, int i) {
1315   if (b) { // expected-warning {{true and false branches are identical}}
1316     if (i < 5)
1317       i += 10;
1318   } else {
1319     if (i < 5)
1320       i += 10;
1321   }
1322 }
1323
1324 void test_identical_bitwise1() {
1325   int a = 5 | 5; // expected-warning {{identical expressions on both sides of bitwise operator}}
1326 }
1327
1328 void test_identical_bitwise2() {
1329   int a = 5;
1330   int b = a | a; // expected-warning {{identical expressions on both sides of bitwise operator}}
1331 }
1332
1333 void test_identical_bitwise3() {
1334   int a = 5;
1335   int b = (a | a); // expected-warning {{identical expressions on both sides of bitwise operator}}
1336 }
1337
1338 void test_identical_bitwise4() {
1339   int a = 4;
1340   int b = a | 4; // no-warning
1341 }
1342
1343 void test_identical_bitwise5() {
1344   int a = 4;
1345   int b = 4;
1346   int c = a | b; // no-warning
1347 }
1348
1349 void test_identical_bitwise6() {
1350   int a = 5;
1351   int b = a | 4 | a; // expected-warning {{identical expressions on both sides of bitwise operator}}
1352 }
1353
1354 void test_identical_bitwise7() {
1355   int a = 5;
1356   int b = func() | func(); // no-warning
1357 }
1358
1359 void test_identical_logical1(int a) {
1360   if (a == 4 && a == 4) // expected-warning {{identical expressions on both sides of logical operator}}
1361     ;
1362 }
1363
1364 void test_identical_logical2(int a) {
1365   if (a == 4 || a == 5 || a == 4) // expected-warning {{identical expressions on both sides of logical operator}}
1366     ;
1367 }
1368
1369 void test_identical_logical3(int a) {
1370   if (a == 4 || a == 5 || a == 6) // no-warning
1371     ;
1372 }
1373
1374 void test_identical_logical4(int a) {
1375   if (a == func() || a == func()) // no-warning
1376     ;
1377 }
1378
1379 #pragma clang diagnostic push
1380 #pragma clang diagnostic ignored "-Wlogical-op-parentheses"
1381 void test_identical_logical5(int x, int y) {
1382   if (x == 4 && y == 5 || x == 4 && y == 6) // no-warning
1383     ;
1384 }
1385
1386 void test_identical_logical6(int x, int y) {
1387   if (x == 4 && y == 5 || x == 4 && y == 5) // expected-warning {{identical expressions on both sides of logical operator}}
1388     ;
1389 }
1390
1391 void test_identical_logical7(int x, int y) {
1392   // FIXME: We should warn here
1393   if (x == 4 && y == 5 || x == 4)
1394     ;
1395 }
1396
1397 void test_identical_logical8(int x, int y) {
1398   // FIXME: We should warn here
1399   if (x == 4 || y == 5 && x == 4)
1400     ;
1401 }
1402
1403 void test_identical_logical9(int x, int y) {
1404   // FIXME: We should warn here
1405   if (x == 4 || x == 4 && y == 5)
1406     ;
1407 }
1408 #pragma clang diagnostic pop
1409
1410 void test_warn_chained_if_stmts_1(int x) {
1411   if (x == 1)
1412     ;
1413   else if (x == 1) // expected-warning {{expression is identical to previous condition}}
1414     ;
1415 }
1416
1417 void test_warn_chained_if_stmts_2(int x) {
1418   if (x == 1)
1419     ;
1420   else if (x == 1) // expected-warning {{expression is identical to previous condition}}
1421     ;
1422   else if (x == 1) // expected-warning {{expression is identical to previous condition}}
1423     ;
1424 }
1425
1426 void test_warn_chained_if_stmts_3(int x) {
1427   if (x == 1)
1428     ;
1429   else if (x == 2)
1430     ;
1431   else if (x == 1) // expected-warning {{expression is identical to previous condition}}
1432     ;
1433 }
1434
1435 void test_warn_chained_if_stmts_4(int x) {
1436   if (x == 1)
1437     ;
1438   else if (func())
1439     ;
1440   else if (x == 1) // expected-warning {{expression is identical to previous condition}}
1441     ;
1442 }
1443
1444 void test_warn_chained_if_stmts_5(int x) {
1445   if (x & 1)
1446     ;
1447   else if (x & 1) // expected-warning {{expression is identical to previous condition}}
1448     ;
1449 }
1450
1451 void test_warn_chained_if_stmts_6(int x) {
1452   if (x == 1)
1453     ;
1454   else if (x == 2)
1455     ;
1456   else if (x == 2) // expected-warning {{expression is identical to previous condition}}
1457     ;
1458   else if (x == 3)
1459     ;
1460 }
1461
1462 void test_warn_chained_if_stmts_7(int x) {
1463   if (x == 1)
1464     ;
1465   else if (x == 2)
1466     ;
1467   else if (x == 3)
1468     ;
1469   else if (x == 2) // expected-warning {{expression is identical to previous condition}}
1470     ;
1471   else if (x == 5)
1472     ;
1473 }
1474
1475 void test_warn_chained_if_stmts_8(int x) {
1476   if (x == 1)
1477     ;
1478   else if (x == 2)
1479     ;
1480   else if (x == 3)
1481     ;
1482   else if (x == 2) // expected-warning {{expression is identical to previous condition}}
1483     ;
1484   else if (x == 5)
1485     ;
1486   else if (x == 3) // expected-warning {{expression is identical to previous condition}}
1487     ;
1488   else if (x == 7)
1489     ;
1490 }
1491
1492 void test_nowarn_chained_if_stmts_1(int x) {
1493   if (func())
1494     ;
1495   else if (func()) // no-warning
1496     ;
1497 }
1498
1499 void test_nowarn_chained_if_stmts_2(int x) {
1500   if (func())
1501     ;
1502   else if (x == 1)
1503     ;
1504   else if (func()) // no-warning
1505     ;
1506 }
1507
1508 void test_nowarn_chained_if_stmts_3(int x) {
1509   if (x++)
1510     ;
1511   else if (x++) // no-warning
1512     ;
1513 }
1514
1515 void test_warn_wchar() {
1516   const wchar_t * a = 0 ? L"Warning" : L"Warning"; // expected-warning {{identical expressions on both sides of ':' in conditional expression}}
1517 }
1518 void test_nowarn_wchar() {
1519   const wchar_t * a = 0 ? L"No" : L"Warning";
1520 }
1521
1522 void test_nowarn_long() {
1523   int a = 0, b = 0;
1524   long c;
1525   if (0) {
1526     b -= a;
1527     c = 0;
1528   } else { // no-warning
1529     b -= a;
1530     c = 0LL;
1531   }
1532 }
1533
1534 // Identical inner conditions
1535
1536 void test_warn_inner_if_1(int x) {
1537   if (x == 1) {
1538     if (x == 1) // expected-warning {{conditions of the inner and outer statements are identical}}
1539       ;
1540   }
1541
1542   // FIXME: Should warn here. The warning is currently not emitted because there
1543   // is code between the conditions.
1544   if (x == 1) {
1545     int y = x;
1546     if (x == 1)
1547       ;
1548   }
1549 }
1550
1551 void test_nowarn_inner_if_1(int x) {
1552   // Don't warn when condition has side effects.
1553   if (x++ == 1) {
1554     if (x++ == 1)
1555       ;
1556   }
1557
1558   // Don't warn when x is changed before inner condition.
1559   if (x < 10) {
1560     x++;
1561     if (x < 10)
1562       ;
1563   }
1564 }