data/gles3/shaders/qualification_order.test

   1 # WARNING: This file is auto-generated. Do NOT modify it manually, but rather
   2 # modify the generating script file. Otherwise changes will be lost!
   3
   4 group variables "Order of qualification in variable declarations."
   5
   6         group valid "Valid orderings."
   7
   8                 case invariant_interp_storage_precision
   9                         expect pass
  10                         values {}
  11
  12                         vertex ""
  13                                 #version 300 es
  14                                 precision mediump float;
  15                                 in highp vec4 dEQP_Position;
  16
  17                                 invariant smooth centroid out lowp float x0;
  18
  19                                  flat out mediump float x1;
  20
  21                                  uniform highp float x2;
  22
  23                                 void main()
  24                                 {
  25                                         x0 = 1.0;
  26                                         x1 = 2.0;
  27                                         gl_Position = dEQP_Position;
  28                                 }
  29                         ""
  30
  31                         fragment ""
  32                                 #version 300 es
  33                                 precision mediump float;
  34                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
  35
  36                                  smooth centroid in lowp float x0;
  37
  38                                  flat in mediump float x1;
  39
  40                                  uniform highp float x2;
  41
  42                                 void main()
  43                                 {
  44                                         float result = (x0 + x1 + x2) / 3.0;
  45                                         dEQP_FragColor = vec4(result, result, result, 1.0);
  46                                 }
  47                         ""
  48                 end
  49                 case interp_storage_precision
  50                         expect pass
  51                         values {}
  52
  53                         vertex ""
  54                                 #version 300 es
  55                                 precision mediump float;
  56                                 in highp vec4 dEQP_Position;
  57
  58                                 smooth centroid out lowp float x0;
  59
  60                                 flat out mediump float x1;
  61
  62                                  uniform highp float x2;
  63
  64                                 void main()
  65                                 {
  66                                         x0 = 1.0;
  67                                         x1 = 2.0;
  68                                         gl_Position = dEQP_Position;
  69                                 }
  70                         ""
  71
  72                         fragment ""
  73                                 #version 300 es
  74                                 precision mediump float;
  75                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
  76
  77                                 smooth centroid in lowp float x0;
  78
  79                                 flat in mediump float x1;
  80
  81                                  uniform highp float x2;
  82
  83                                 void main()
  84                                 {
  85                                         float result = (x0 + x1 + x2) / 3.0;
  86                                         dEQP_FragColor = vec4(result, result, result, 1.0);
  87                                 }
  88                         ""
  89                 end
  90                 case invariant_interp_storage
  91                         expect pass
  92                         values {}
  93
  94                         vertex ""
  95                                 #version 300 es
  96                                 precision mediump float;
  97                                 in highp vec4 dEQP_Position;
  98
  99                                 invariant smooth centroid out float x0;
 100
 101                                  flat out float x1;
 102
 103                                  uniform float x2;
 104
 105                                 void main()
 106                                 {
 107                                         x0 = 1.0;
 108                                         x1 = 2.0;
 109                                         gl_Position = dEQP_Position;
 110                                 }
 111                         ""
 112
 113                         fragment ""
 114                                 #version 300 es
 115                                 precision mediump float;
 116                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 117
 118                                  smooth centroid in float x0;
 119
 120                                  flat in float x1;
 121
 122                                  uniform float x2;
 123
 124                                 void main()
 125                                 {
 126                                         float result = (x0 + x1 + x2) / 3.0;
 127                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 128                                 }
 129                         ""
 130                 end
 131                 case invariant_storage_precision
 132                         expect pass
 133                         values {}
 134
 135                         vertex ""
 136                                 #version 300 es
 137                                 precision mediump float;
 138                                 in highp vec4 dEQP_Position;
 139
 140                                 invariant centroid out lowp float x0;
 141
 142                                  out mediump float x1;
 143
 144                                  uniform highp float x2;
 145
 146                                 void main()
 147                                 {
 148                                         x0 = 1.0;
 149                                         x1 = 2.0;
 150                                         gl_Position = dEQP_Position;
 151                                 }
 152                         ""
 153
 154                         fragment ""
 155                                 #version 300 es
 156                                 precision mediump float;
 157                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 158
 159                                  centroid in lowp float x0;
 160
 161                                  in mediump float x1;
 162
 163                                  uniform highp float x2;
 164
 165                                 void main()
 166                                 {
 167                                         float result = (x0 + x1 + x2) / 3.0;
 168                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 169                                 }
 170                         ""
 171                 end
 172                 case storage_precision
 173                         expect pass
 174                         values {}
 175
 176                         vertex ""
 177                                 #version 300 es
 178                                 precision mediump float;
 179                                 in highp vec4 dEQP_Position;
 180
 181                                 centroid out lowp float x0;
 182
 183                                 out mediump float x1;
 184
 185                                 uniform highp float x2;
 186
 187                                 void main()
 188                                 {
 189                                         x0 = 1.0;
 190                                         x1 = 2.0;
 191                                         gl_Position = dEQP_Position;
 192                                 }
 193                         ""
 194
 195                         fragment ""
 196                                 #version 300 es
 197                                 precision mediump float;
 198                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 199
 200                                 centroid in lowp float x0;
 201
 202                                 in mediump float x1;
 203
 204                                 uniform highp float x2;
 205
 206                                 void main()
 207                                 {
 208                                         float result = (x0 + x1 + x2) / 3.0;
 209                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 210                                 }
 211                         ""
 212                 end
 213                 case interp_storage
 214                         expect pass
 215                         values {}
 216
 217                         vertex ""
 218                                 #version 300 es
 219                                 precision mediump float;
 220                                 in highp vec4 dEQP_Position;
 221
 222                                 smooth centroid out float x0;
 223
 224                                 flat out float x1;
 225
 226                                  uniform float x2;
 227
 228                                 void main()
 229                                 {
 230                                         x0 = 1.0;
 231                                         x1 = 2.0;
 232                                         gl_Position = dEQP_Position;
 233                                 }
 234                         ""
 235
 236                         fragment ""
 237                                 #version 300 es
 238                                 precision mediump float;
 239                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 240
 241                                 smooth centroid in float x0;
 242
 243                                 flat in float x1;
 244
 245                                  uniform float x2;
 246
 247                                 void main()
 248                                 {
 249                                         float result = (x0 + x1 + x2) / 3.0;
 250                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 251                                 }
 252                         ""
 253                 end
 254                 case invariant_storage
 255                         expect pass
 256                         values {}
 257
 258                         vertex ""
 259                                 #version 300 es
 260                                 precision mediump float;
 261                                 in highp vec4 dEQP_Position;
 262
 263                                 invariant centroid out float x0;
 264
 265                                  out float x1;
 266
 267                                  uniform float x2;
 268
 269                                 void main()
 270                                 {
 271                                         x0 = 1.0;
 272                                         x1 = 2.0;
 273                                         gl_Position = dEQP_Position;
 274                                 }
 275                         ""
 276
 277                         fragment ""
 278                                 #version 300 es
 279                                 precision mediump float;
 280                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 281
 282                                  centroid in float x0;
 283
 284                                  in float x1;
 285
 286                                  uniform float x2;
 287
 288                                 void main()
 289                                 {
 290                                         float result = (x0 + x1 + x2) / 3.0;
 291                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 292                                 }
 293                         ""
 294                 end
 295
 296         end # valid
 297         group invalid "Invalid orderings."
 298
 299                 case invariant_interp_precision_storage
 300                         expect compile_fail
 301                         values {}
 302
 303                         vertex ""
 304                                 #version 300 es
 305                                 precision mediump float;
 306                                 in highp vec4 dEQP_Position;
 307
 308                                 invariant smooth lowp centroid out float x0;
 309
 310                                  flat mediump out float x1;
 311
 312                                  highp uniform float x2;
 313
 314                                 void main()
 315                                 {
 316                                         x0 = 1.0;
 317                                         x1 = 2.0;
 318                                         gl_Position = dEQP_Position;
 319                                 }
 320                         ""
 321
 322                         fragment ""
 323                                 #version 300 es
 324                                 precision mediump float;
 325                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 326
 327                                  smooth lowp centroid in float x0;
 328
 329                                  flat mediump in float x1;
 330
 331                                  highp uniform float x2;
 332
 333                                 void main()
 334                                 {
 335                                         float result = (x0 + x1 + x2) / 3.0;
 336                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 337                                 }
 338                         ""
 339                 end
 340                 case invariant_storage_interp_precision
 341                         expect compile_fail
 342                         values {}
 343
 344                         vertex ""
 345                                 #version 300 es
 346                                 precision mediump float;
 347                                 in highp vec4 dEQP_Position;
 348
 349                                 invariant centroid out smooth lowp float x0;
 350
 351                                  out flat mediump float x1;
 352
 353                                  uniform highp float x2;
 354
 355                                 void main()
 356                                 {
 357                                         x0 = 1.0;
 358                                         x1 = 2.0;
 359                                         gl_Position = dEQP_Position;
 360                                 }
 361                         ""
 362
 363                         fragment ""
 364                                 #version 300 es
 365                                 precision mediump float;
 366                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 367
 368                                  centroid in smooth lowp float x0;
 369
 370                                  in flat mediump float x1;
 371
 372                                  uniform highp float x2;
 373
 374                                 void main()
 375                                 {
 376                                         float result = (x0 + x1 + x2) / 3.0;
 377                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 378                                 }
 379                         ""
 380                 end
 381                 case invariant_storage_precision_interp
 382                         expect compile_fail
 383                         values {}
 384
 385                         vertex ""
 386                                 #version 300 es
 387                                 precision mediump float;
 388                                 in highp vec4 dEQP_Position;
 389
 390                                 invariant centroid out lowp smooth float x0;
 391
 392                                  out mediump flat float x1;
 393
 394                                  uniform highp float x2;
 395
 396                                 void main()
 397                                 {
 398                                         x0 = 1.0;
 399                                         x1 = 2.0;
 400                                         gl_Position = dEQP_Position;
 401                                 }
 402                         ""
 403
 404                         fragment ""
 405                                 #version 300 es
 406                                 precision mediump float;
 407                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 408
 409                                  centroid in lowp smooth float x0;
 410
 411                                  in mediump flat float x1;
 412
 413                                  uniform highp float x2;
 414
 415                                 void main()
 416                                 {
 417                                         float result = (x0 + x1 + x2) / 3.0;
 418                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 419                                 }
 420                         ""
 421                 end
 422                 case invariant_precision_interp_storage
 423                         expect compile_fail
 424                         values {}
 425
 426                         vertex ""
 427                                 #version 300 es
 428                                 precision mediump float;
 429                                 in highp vec4 dEQP_Position;
 430
 431                                 invariant lowp smooth centroid out float x0;
 432
 433                                  mediump flat out float x1;
 434
 435                                  highp uniform float x2;
 436
 437                                 void main()
 438                                 {
 439                                         x0 = 1.0;
 440                                         x1 = 2.0;
 441                                         gl_Position = dEQP_Position;
 442                                 }
 443                         ""
 444
 445                         fragment ""
 446                                 #version 300 es
 447                                 precision mediump float;
 448                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 449
 450                                  lowp smooth centroid in float x0;
 451
 452                                  mediump flat in float x1;
 453
 454                                  highp uniform float x2;
 455
 456                                 void main()
 457                                 {
 458                                         float result = (x0 + x1 + x2) / 3.0;
 459                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 460                                 }
 461                         ""
 462                 end
 463                 case invariant_precision_storage_interp
 464                         expect compile_fail
 465                         values {}
 466
 467                         vertex ""
 468                                 #version 300 es
 469                                 precision mediump float;
 470                                 in highp vec4 dEQP_Position;
 471
 472                                 invariant lowp centroid out smooth float x0;
 473
 474                                  mediump out flat float x1;
 475
 476                                  highp uniform float x2;
 477
 478                                 void main()
 479                                 {
 480                                         x0 = 1.0;
 481                                         x1 = 2.0;
 482                                         gl_Position = dEQP_Position;
 483                                 }
 484                         ""
 485
 486                         fragment ""
 487                                 #version 300 es
 488                                 precision mediump float;
 489                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 490
 491                                  lowp centroid in smooth float x0;
 492
 493                                  mediump in flat float x1;
 494
 495                                  highp uniform float x2;
 496
 497                                 void main()
 498                                 {
 499                                         float result = (x0 + x1 + x2) / 3.0;
 500                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 501                                 }
 502                         ""
 503                 end
 504                 case interp_invariant_storage_precision
 505                         expect compile_fail
 506                         values {}
 507
 508                         vertex ""
 509                                 #version 300 es
 510                                 precision mediump float;
 511                                 in highp vec4 dEQP_Position;
 512
 513                                 smooth invariant centroid out lowp float x0;
 514
 515                                 flat out mediump float x1;
 516
 517                                  uniform highp float x2;
 518
 519                                 void main()
 520                                 {
 521                                         x0 = 1.0;
 522                                         x1 = 2.0;
 523                                         gl_Position = dEQP_Position;
 524                                 }
 525                         ""
 526
 527                         fragment ""
 528                                 #version 300 es
 529                                 precision mediump float;
 530                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 531
 532                                 smooth  centroid in lowp float x0;
 533
 534                                 flat in mediump float x1;
 535
 536                                  uniform highp float x2;
 537
 538                                 void main()
 539                                 {
 540                                         float result = (x0 + x1 + x2) / 3.0;
 541                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 542                                 }
 543                         ""
 544                 end
 545                 case interp_invariant_precision_storage
 546                         expect compile_fail
 547                         values {}
 548
 549                         vertex ""
 550                                 #version 300 es
 551                                 precision mediump float;
 552                                 in highp vec4 dEQP_Position;
 553
 554                                 smooth invariant lowp centroid out float x0;
 555
 556                                 flat mediump out float x1;
 557
 558                                  highp uniform float x2;
 559
 560                                 void main()
 561                                 {
 562                                         x0 = 1.0;
 563                                         x1 = 2.0;
 564                                         gl_Position = dEQP_Position;
 565                                 }
 566                         ""
 567
 568                         fragment ""
 569                                 #version 300 es
 570                                 precision mediump float;
 571                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 572
 573                                 smooth  lowp centroid in float x0;
 574
 575                                 flat mediump in float x1;
 576
 577                                  highp uniform float x2;
 578
 579                                 void main()
 580                                 {
 581                                         float result = (x0 + x1 + x2) / 3.0;
 582                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 583                                 }
 584                         ""
 585                 end
 586                 case interp_storage_invariant_precision
 587                         expect compile_fail
 588                         values {}
 589
 590                         vertex ""
 591                                 #version 300 es
 592                                 precision mediump float;
 593                                 in highp vec4 dEQP_Position;
 594
 595                                 smooth centroid out invariant lowp float x0;
 596
 597                                 flat out mediump float x1;
 598
 599                                  uniform highp float x2;
 600
 601                                 void main()
 602                                 {
 603                                         x0 = 1.0;
 604                                         x1 = 2.0;
 605                                         gl_Position = dEQP_Position;
 606                                 }
 607                         ""
 608
 609                         fragment ""
 610                                 #version 300 es
 611                                 precision mediump float;
 612                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 613
 614                                 smooth centroid in  lowp float x0;
 615
 616                                 flat in mediump float x1;
 617
 618                                  uniform highp float x2;
 619
 620                                 void main()
 621                                 {
 622                                         float result = (x0 + x1 + x2) / 3.0;
 623                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 624                                 }
 625                         ""
 626                 end
 627                 case interp_storage_precision_invariant
 628                         expect compile_fail
 629                         values {}
 630
 631                         vertex ""
 632                                 #version 300 es
 633                                 precision mediump float;
 634                                 in highp vec4 dEQP_Position;
 635
 636                                 smooth centroid out lowp invariant float x0;
 637
 638                                 flat out mediump float x1;
 639
 640                                  uniform highp float x2;
 641
 642                                 void main()
 643                                 {
 644                                         x0 = 1.0;
 645                                         x1 = 2.0;
 646                                         gl_Position = dEQP_Position;
 647                                 }
 648                         ""
 649
 650                         fragment ""
 651                                 #version 300 es
 652                                 precision mediump float;
 653                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 654
 655                                 smooth centroid in lowp  float x0;
 656
 657                                 flat in mediump float x1;
 658
 659                                  uniform highp float x2;
 660
 661                                 void main()
 662                                 {
 663                                         float result = (x0 + x1 + x2) / 3.0;
 664                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 665                                 }
 666                         ""
 667                 end
 668                 case interp_precision_invariant_storage
 669                         expect compile_fail
 670                         values {}
 671
 672                         vertex ""
 673                                 #version 300 es
 674                                 precision mediump float;
 675                                 in highp vec4 dEQP_Position;
 676
 677                                 smooth lowp invariant centroid out float x0;
 678
 679                                 flat mediump out float x1;
 680
 681                                  highp uniform float x2;
 682
 683                                 void main()
 684                                 {
 685                                         x0 = 1.0;
 686                                         x1 = 2.0;
 687                                         gl_Position = dEQP_Position;
 688                                 }
 689                         ""
 690
 691                         fragment ""
 692                                 #version 300 es
 693                                 precision mediump float;
 694                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 695
 696                                 smooth lowp  centroid in float x0;
 697
 698                                 flat mediump in float x1;
 699
 700                                  highp uniform float x2;
 701
 702                                 void main()
 703                                 {
 704                                         float result = (x0 + x1 + x2) / 3.0;
 705                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 706                                 }
 707                         ""
 708                 end
 709                 case interp_precision_storage_invariant
 710                         expect compile_fail
 711                         values {}
 712
 713                         vertex ""
 714                                 #version 300 es
 715                                 precision mediump float;
 716                                 in highp vec4 dEQP_Position;
 717
 718                                 smooth lowp centroid out invariant float x0;
 719
 720                                 flat mediump out float x1;
 721
 722                                  highp uniform float x2;
 723
 724                                 void main()
 725                                 {
 726                                         x0 = 1.0;
 727                                         x1 = 2.0;
 728                                         gl_Position = dEQP_Position;
 729                                 }
 730                         ""
 731
 732                         fragment ""
 733                                 #version 300 es
 734                                 precision mediump float;
 735                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 736
 737                                 smooth lowp centroid in  float x0;
 738
 739                                 flat mediump in float x1;
 740
 741                                  highp uniform float x2;
 742
 743                                 void main()
 744                                 {
 745                                         float result = (x0 + x1 + x2) / 3.0;
 746                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 747                                 }
 748                         ""
 749                 end
 750                 case storage_invariant_interp_precision
 751                         expect compile_fail
 752                         values {}
 753
 754                         vertex ""
 755                                 #version 300 es
 756                                 precision mediump float;
 757                                 in highp vec4 dEQP_Position;
 758
 759                                 centroid out invariant smooth lowp float x0;
 760
 761                                 out flat mediump float x1;
 762
 763                                 uniform  highp float x2;
 764
 765                                 void main()
 766                                 {
 767                                         x0 = 1.0;
 768                                         x1 = 2.0;
 769                                         gl_Position = dEQP_Position;
 770                                 }
 771                         ""
 772
 773                         fragment ""
 774                                 #version 300 es
 775                                 precision mediump float;
 776                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 777
 778                                 centroid in  smooth lowp float x0;
 779
 780                                 in flat mediump float x1;
 781
 782                                 uniform  highp float x2;
 783
 784                                 void main()
 785                                 {
 786                                         float result = (x0 + x1 + x2) / 3.0;
 787                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 788                                 }
 789                         ""
 790                 end
 791                 case storage_invariant_precision_interp
 792                         expect compile_fail
 793                         values {}
 794
 795                         vertex ""
 796                                 #version 300 es
 797                                 precision mediump float;
 798                                 in highp vec4 dEQP_Position;
 799
 800                                 centroid out invariant lowp smooth float x0;
 801
 802                                 out mediump flat float x1;
 803
 804                                 uniform highp float x2;
 805
 806                                 void main()
 807                                 {
 808                                         x0 = 1.0;
 809                                         x1 = 2.0;
 810                                         gl_Position = dEQP_Position;
 811                                 }
 812                         ""
 813
 814                         fragment ""
 815                                 #version 300 es
 816                                 precision mediump float;
 817                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 818
 819                                 centroid in  lowp smooth float x0;
 820
 821                                 in mediump flat float x1;
 822
 823                                 uniform highp float x2;
 824
 825                                 void main()
 826                                 {
 827                                         float result = (x0 + x1 + x2) / 3.0;
 828                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 829                                 }
 830                         ""
 831                 end
 832                 case storage_interp_invariant_precision
 833                         expect compile_fail
 834                         values {}
 835
 836                         vertex ""
 837                                 #version 300 es
 838                                 precision mediump float;
 839                                 in highp vec4 dEQP_Position;
 840
 841                                 centroid out smooth invariant lowp float x0;
 842
 843                                 out flat mediump float x1;
 844
 845                                 uniform  highp float x2;
 846
 847                                 void main()
 848                                 {
 849                                         x0 = 1.0;
 850                                         x1 = 2.0;
 851                                         gl_Position = dEQP_Position;
 852                                 }
 853                         ""
 854
 855                         fragment ""
 856                                 #version 300 es
 857                                 precision mediump float;
 858                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 859
 860                                 centroid in smooth  lowp float x0;
 861
 862                                 in flat mediump float x1;
 863
 864                                 uniform  highp float x2;
 865
 866                                 void main()
 867                                 {
 868                                         float result = (x0 + x1 + x2) / 3.0;
 869                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 870                                 }
 871                         ""
 872                 end
 873                 case storage_interp_precision_invariant
 874                         expect compile_fail
 875                         values {}
 876
 877                         vertex ""
 878                                 #version 300 es
 879                                 precision mediump float;
 880                                 in highp vec4 dEQP_Position;
 881
 882                                 centroid out smooth lowp invariant float x0;
 883
 884                                 out flat mediump float x1;
 885
 886                                 uniform highp float x2;
 887
 888                                 void main()
 889                                 {
 890                                         x0 = 1.0;
 891                                         x1 = 2.0;
 892                                         gl_Position = dEQP_Position;
 893                                 }
 894                         ""
 895
 896                         fragment ""
 897                                 #version 300 es
 898                                 precision mediump float;
 899                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 900
 901                                 centroid in smooth lowp  float x0;
 902
 903                                 in flat mediump float x1;
 904
 905                                 uniform highp float x2;
 906
 907                                 void main()
 908                                 {
 909                                         float result = (x0 + x1 + x2) / 3.0;
 910                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 911                                 }
 912                         ""
 913                 end
 914                 case storage_precision_invariant_interp
 915                         expect compile_fail
 916                         values {}
 917
 918                         vertex ""
 919                                 #version 300 es
 920                                 precision mediump float;
 921                                 in highp vec4 dEQP_Position;
 922
 923                                 centroid out lowp invariant smooth float x0;
 924
 925                                 out mediump flat float x1;
 926
 927                                 uniform highp  float x2;
 928
 929                                 void main()
 930                                 {
 931                                         x0 = 1.0;
 932                                         x1 = 2.0;
 933                                         gl_Position = dEQP_Position;
 934                                 }
 935                         ""
 936
 937                         fragment ""
 938                                 #version 300 es
 939                                 precision mediump float;
 940                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 941
 942                                 centroid in lowp  smooth float x0;
 943
 944                                 in mediump flat float x1;
 945
 946                                 uniform highp  float x2;
 947
 948                                 void main()
 949                                 {
 950                                         float result = (x0 + x1 + x2) / 3.0;
 951                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 952                                 }
 953                         ""
 954                 end
 955                 case storage_precision_interp_invariant
 956                         expect compile_fail
 957                         values {}
 958
 959                         vertex ""
 960                                 #version 300 es
 961                                 precision mediump float;
 962                                 in highp vec4 dEQP_Position;
 963
 964                                 centroid out lowp smooth invariant float x0;
 965
 966                                 out mediump flat float x1;
 967
 968                                 uniform highp  float x2;
 969
 970                                 void main()
 971                                 {
 972                                         x0 = 1.0;
 973                                         x1 = 2.0;
 974                                         gl_Position = dEQP_Position;
 975                                 }
 976                         ""
 977
 978                         fragment ""
 979                                 #version 300 es
 980                                 precision mediump float;
 981                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
 982
 983                                 centroid in lowp smooth  float x0;
 984
 985                                 in mediump flat float x1;
 986
 987                                 uniform highp  float x2;
 988
 989                                 void main()
 990                                 {
 991                                         float result = (x0 + x1 + x2) / 3.0;
 992                                         dEQP_FragColor = vec4(result, result, result, 1.0);
 993                                 }
 994                         ""
 995                 end
 996                 case precision_invariant_interp_storage
 997                         expect compile_fail
 998                         values {}
 999
1000                         vertex ""
1001                                 #version 300 es
1002                                 precision mediump float;
1003                                 in highp vec4 dEQP_Position;
1004
1005                                 lowp invariant smooth centroid out float x0;
1006
1007                                 mediump flat out float x1;
1008
1009                                 highp  uniform float x2;
1010
1011                                 void main()
1012                                 {
1013                                         x0 = 1.0;
1014                                         x1 = 2.0;
1015                                         gl_Position = dEQP_Position;
1016                                 }
1017                         ""
1018
1019                         fragment ""
1020                                 #version 300 es
1021                                 precision mediump float;
1022                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1023
1024                                 lowp  smooth centroid in float x0;
1025
1026                                 mediump flat in float x1;
1027
1028                                 highp  uniform float x2;
1029
1030                                 void main()
1031                                 {
1032                                         float result = (x0 + x1 + x2) / 3.0;
1033                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1034                                 }
1035                         ""
1036                 end
1037                 case precision_invariant_storage_interp
1038                         expect compile_fail
1039                         values {}
1040
1041                         vertex ""
1042                                 #version 300 es
1043                                 precision mediump float;
1044                                 in highp vec4 dEQP_Position;
1045
1046                                 lowp invariant centroid out smooth float x0;
1047
1048                                 mediump out flat float x1;
1049
1050                                 highp uniform float x2;
1051
1052                                 void main()
1053                                 {
1054                                         x0 = 1.0;
1055                                         x1 = 2.0;
1056                                         gl_Position = dEQP_Position;
1057                                 }
1058                         ""
1059
1060                         fragment ""
1061                                 #version 300 es
1062                                 precision mediump float;
1063                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1064
1065                                 lowp  centroid in smooth float x0;
1066
1067                                 mediump in flat float x1;
1068
1069                                 highp uniform float x2;
1070
1071                                 void main()
1072                                 {
1073                                         float result = (x0 + x1 + x2) / 3.0;
1074                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1075                                 }
1076                         ""
1077                 end
1078                 case precision_interp_invariant_storage
1079                         expect compile_fail
1080                         values {}
1081
1082                         vertex ""
1083                                 #version 300 es
1084                                 precision mediump float;
1085                                 in highp vec4 dEQP_Position;
1086
1087                                 lowp smooth invariant centroid out float x0;
1088
1089                                 mediump flat out float x1;
1090
1091                                 highp  uniform float x2;
1092
1093                                 void main()
1094                                 {
1095                                         x0 = 1.0;
1096                                         x1 = 2.0;
1097                                         gl_Position = dEQP_Position;
1098                                 }
1099                         ""
1100
1101                         fragment ""
1102                                 #version 300 es
1103                                 precision mediump float;
1104                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1105
1106                                 lowp smooth  centroid in float x0;
1107
1108                                 mediump flat in float x1;
1109
1110                                 highp  uniform float x2;
1111
1112                                 void main()
1113                                 {
1114                                         float result = (x0 + x1 + x2) / 3.0;
1115                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1116                                 }
1117                         ""
1118                 end
1119                 case precision_interp_storage_invariant
1120                         expect compile_fail
1121                         values {}
1122
1123                         vertex ""
1124                                 #version 300 es
1125                                 precision mediump float;
1126                                 in highp vec4 dEQP_Position;
1127
1128                                 lowp smooth centroid out invariant float x0;
1129
1130                                 mediump flat out float x1;
1131
1132                                 highp uniform float x2;
1133
1134                                 void main()
1135                                 {
1136                                         x0 = 1.0;
1137                                         x1 = 2.0;
1138                                         gl_Position = dEQP_Position;
1139                                 }
1140                         ""
1141
1142                         fragment ""
1143                                 #version 300 es
1144                                 precision mediump float;
1145                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1146
1147                                 lowp smooth centroid in  float x0;
1148
1149                                 mediump flat in float x1;
1150
1151                                 highp uniform float x2;
1152
1153                                 void main()
1154                                 {
1155                                         float result = (x0 + x1 + x2) / 3.0;
1156                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1157                                 }
1158                         ""
1159                 end
1160                 case precision_storage_invariant_interp
1161                         expect compile_fail
1162                         values {}
1163
1164                         vertex ""
1165                                 #version 300 es
1166                                 precision mediump float;
1167                                 in highp vec4 dEQP_Position;
1168
1169                                 lowp centroid out invariant smooth float x0;
1170
1171                                 mediump out flat float x1;
1172
1173                                 highp uniform  float x2;
1174
1175                                 void main()
1176                                 {
1177                                         x0 = 1.0;
1178                                         x1 = 2.0;
1179                                         gl_Position = dEQP_Position;
1180                                 }
1181                         ""
1182
1183                         fragment ""
1184                                 #version 300 es
1185                                 precision mediump float;
1186                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1187
1188                                 lowp centroid in  smooth float x0;
1189
1190                                 mediump in flat float x1;
1191
1192                                 highp uniform  float x2;
1193
1194                                 void main()
1195                                 {
1196                                         float result = (x0 + x1 + x2) / 3.0;
1197                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1198                                 }
1199                         ""
1200                 end
1201                 case precision_storage_interp_invariant
1202                         expect compile_fail
1203                         values {}
1204
1205                         vertex ""
1206                                 #version 300 es
1207                                 precision mediump float;
1208                                 in highp vec4 dEQP_Position;
1209
1210                                 lowp centroid out smooth invariant float x0;
1211
1212                                 mediump out flat float x1;
1213
1214                                 highp uniform  float x2;
1215
1216                                 void main()
1217                                 {
1218                                         x0 = 1.0;
1219                                         x1 = 2.0;
1220                                         gl_Position = dEQP_Position;
1221                                 }
1222                         ""
1223
1224                         fragment ""
1225                                 #version 300 es
1226                                 precision mediump float;
1227                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1228
1229                                 lowp centroid in smooth  float x0;
1230
1231                                 mediump in flat float x1;
1232
1233                                 highp uniform  float x2;
1234
1235                                 void main()
1236                                 {
1237                                         float result = (x0 + x1 + x2) / 3.0;
1238                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1239                                 }
1240                         ""
1241                 end
1242                 case interp_precision_storage
1243                         expect compile_fail
1244                         values {}
1245
1246                         vertex ""
1247                                 #version 300 es
1248                                 precision mediump float;
1249                                 in highp vec4 dEQP_Position;
1250
1251                                 smooth lowp centroid out float x0;
1252
1253                                 flat mediump out float x1;
1254
1255                                  highp uniform float x2;
1256
1257                                 void main()
1258                                 {
1259                                         x0 = 1.0;
1260                                         x1 = 2.0;
1261                                         gl_Position = dEQP_Position;
1262                                 }
1263                         ""
1264
1265                         fragment ""
1266                                 #version 300 es
1267                                 precision mediump float;
1268                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1269
1270                                 smooth lowp centroid in float x0;
1271
1272                                 flat mediump in float x1;
1273
1274                                  highp uniform float x2;
1275
1276                                 void main()
1277                                 {
1278                                         float result = (x0 + x1 + x2) / 3.0;
1279                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1280                                 }
1281                         ""
1282                 end
1283                 case storage_interp_precision
1284                         expect compile_fail
1285                         values {}
1286
1287                         vertex ""
1288                                 #version 300 es
1289                                 precision mediump float;
1290                                 in highp vec4 dEQP_Position;
1291
1292                                 centroid out smooth lowp float x0;
1293
1294                                 out flat mediump float x1;
1295
1296                                 uniform highp float x2;
1297
1298                                 void main()
1299                                 {
1300                                         x0 = 1.0;
1301                                         x1 = 2.0;
1302                                         gl_Position = dEQP_Position;
1303                                 }
1304                         ""
1305
1306                         fragment ""
1307                                 #version 300 es
1308                                 precision mediump float;
1309                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1310
1311                                 centroid in smooth lowp float x0;
1312
1313                                 in flat mediump float x1;
1314
1315                                 uniform highp float x2;
1316
1317                                 void main()
1318                                 {
1319                                         float result = (x0 + x1 + x2) / 3.0;
1320                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1321                                 }
1322                         ""
1323                 end
1324                 case storage_precision_interp
1325                         expect compile_fail
1326                         values {}
1327
1328                         vertex ""
1329                                 #version 300 es
1330                                 precision mediump float;
1331                                 in highp vec4 dEQP_Position;
1332
1333                                 centroid out lowp smooth float x0;
1334
1335                                 out mediump flat float x1;
1336
1337                                 uniform highp float x2;
1338
1339                                 void main()
1340                                 {
1341                                         x0 = 1.0;
1342                                         x1 = 2.0;
1343                                         gl_Position = dEQP_Position;
1344                                 }
1345                         ""
1346
1347                         fragment ""
1348                                 #version 300 es
1349                                 precision mediump float;
1350                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1351
1352                                 centroid in lowp smooth float x0;
1353
1354                                 in mediump flat float x1;
1355
1356                                 uniform highp float x2;
1357
1358                                 void main()
1359                                 {
1360                                         float result = (x0 + x1 + x2) / 3.0;
1361                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1362                                 }
1363                         ""
1364                 end
1365                 case precision_interp_storage
1366                         expect compile_fail
1367                         values {}
1368
1369                         vertex ""
1370                                 #version 300 es
1371                                 precision mediump float;
1372                                 in highp vec4 dEQP_Position;
1373
1374                                 lowp smooth centroid out float x0;
1375
1376                                 mediump flat out float x1;
1377
1378                                 highp uniform float x2;
1379
1380                                 void main()
1381                                 {
1382                                         x0 = 1.0;
1383                                         x1 = 2.0;
1384                                         gl_Position = dEQP_Position;
1385                                 }
1386                         ""
1387
1388                         fragment ""
1389                                 #version 300 es
1390                                 precision mediump float;
1391                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1392
1393                                 lowp smooth centroid in float x0;
1394
1395                                 mediump flat in float x1;
1396
1397                                 highp uniform float x2;
1398
1399                                 void main()
1400                                 {
1401                                         float result = (x0 + x1 + x2) / 3.0;
1402                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1403                                 }
1404                         ""
1405                 end
1406                 case precision_storage_interp
1407                         expect compile_fail
1408                         values {}
1409
1410                         vertex ""
1411                                 #version 300 es
1412                                 precision mediump float;
1413                                 in highp vec4 dEQP_Position;
1414
1415                                 lowp centroid out smooth float x0;
1416
1417                                 mediump out flat float x1;
1418
1419                                 highp uniform float x2;
1420
1421                                 void main()
1422                                 {
1423                                         x0 = 1.0;
1424                                         x1 = 2.0;
1425                                         gl_Position = dEQP_Position;
1426                                 }
1427                         ""
1428
1429                         fragment ""
1430                                 #version 300 es
1431                                 precision mediump float;
1432                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1433
1434                                 lowp centroid in smooth float x0;
1435
1436                                 mediump in flat float x1;
1437
1438                                 highp uniform float x2;
1439
1440                                 void main()
1441                                 {
1442                                         float result = (x0 + x1 + x2) / 3.0;
1443                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1444                                 }
1445                         ""
1446                 end
1447                 case invariant_storage_interp
1448                         expect compile_fail
1449                         values {}
1450
1451                         vertex ""
1452                                 #version 300 es
1453                                 precision mediump float;
1454                                 in highp vec4 dEQP_Position;
1455
1456                                 invariant centroid out smooth float x0;
1457
1458                                  out flat float x1;
1459
1460                                  uniform float x2;
1461
1462                                 void main()
1463                                 {
1464                                         x0 = 1.0;
1465                                         x1 = 2.0;
1466                                         gl_Position = dEQP_Position;
1467                                 }
1468                         ""
1469
1470                         fragment ""
1471                                 #version 300 es
1472                                 precision mediump float;
1473                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1474
1475                                  centroid in smooth float x0;
1476
1477                                  in flat float x1;
1478
1479                                  uniform float x2;
1480
1481                                 void main()
1482                                 {
1483                                         float result = (x0 + x1 + x2) / 3.0;
1484                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1485                                 }
1486                         ""
1487                 end
1488                 case interp_invariant_storage
1489                         expect compile_fail
1490                         values {}
1491
1492                         vertex ""
1493                                 #version 300 es
1494                                 precision mediump float;
1495                                 in highp vec4 dEQP_Position;
1496
1497                                 smooth invariant centroid out float x0;
1498
1499                                 flat out float x1;
1500
1501                                  uniform float x2;
1502
1503                                 void main()
1504                                 {
1505                                         x0 = 1.0;
1506                                         x1 = 2.0;
1507                                         gl_Position = dEQP_Position;
1508                                 }
1509                         ""
1510
1511                         fragment ""
1512                                 #version 300 es
1513                                 precision mediump float;
1514                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1515
1516                                 smooth  centroid in float x0;
1517
1518                                 flat in float x1;
1519
1520                                  uniform float x2;
1521
1522                                 void main()
1523                                 {
1524                                         float result = (x0 + x1 + x2) / 3.0;
1525                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1526                                 }
1527                         ""
1528                 end
1529                 case interp_storage_invariant
1530                         expect compile_fail
1531                         values {}
1532
1533                         vertex ""
1534                                 #version 300 es
1535                                 precision mediump float;
1536                                 in highp vec4 dEQP_Position;
1537
1538                                 smooth centroid out invariant float x0;
1539
1540                                 flat out float x1;
1541
1542                                  uniform float x2;
1543
1544                                 void main()
1545                                 {
1546                                         x0 = 1.0;
1547                                         x1 = 2.0;
1548                                         gl_Position = dEQP_Position;
1549                                 }
1550                         ""
1551
1552                         fragment ""
1553                                 #version 300 es
1554                                 precision mediump float;
1555                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1556
1557                                 smooth centroid in  float x0;
1558
1559                                 flat in float x1;
1560
1561                                  uniform float x2;
1562
1563                                 void main()
1564                                 {
1565                                         float result = (x0 + x1 + x2) / 3.0;
1566                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1567                                 }
1568                         ""
1569                 end
1570                 case storage_invariant_interp
1571                         expect compile_fail
1572                         values {}
1573
1574                         vertex ""
1575                                 #version 300 es
1576                                 precision mediump float;
1577                                 in highp vec4 dEQP_Position;
1578
1579                                 centroid out invariant smooth float x0;
1580
1581                                 out flat float x1;
1582
1583                                 uniform  float x2;
1584
1585                                 void main()
1586                                 {
1587                                         x0 = 1.0;
1588                                         x1 = 2.0;
1589                                         gl_Position = dEQP_Position;
1590                                 }
1591                         ""
1592
1593                         fragment ""
1594                                 #version 300 es
1595                                 precision mediump float;
1596                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1597
1598                                 centroid in  smooth float x0;
1599
1600                                 in flat float x1;
1601
1602                                 uniform  float x2;
1603
1604                                 void main()
1605                                 {
1606                                         float result = (x0 + x1 + x2) / 3.0;
1607                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1608                                 }
1609                         ""
1610                 end
1611                 case storage_interp_invariant
1612                         expect compile_fail
1613                         values {}
1614
1615                         vertex ""
1616                                 #version 300 es
1617                                 precision mediump float;
1618                                 in highp vec4 dEQP_Position;
1619
1620                                 centroid out smooth invariant float x0;
1621
1622                                 out flat float x1;
1623
1624                                 uniform  float x2;
1625
1626                                 void main()
1627                                 {
1628                                         x0 = 1.0;
1629                                         x1 = 2.0;
1630                                         gl_Position = dEQP_Position;
1631                                 }
1632                         ""
1633
1634                         fragment ""
1635                                 #version 300 es
1636                                 precision mediump float;
1637                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1638
1639                                 centroid in smooth  float x0;
1640
1641                                 in flat float x1;
1642
1643                                 uniform  float x2;
1644
1645                                 void main()
1646                                 {
1647                                         float result = (x0 + x1 + x2) / 3.0;
1648                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1649                                 }
1650                         ""
1651                 end
1652                 case invariant_precision_storage
1653                         expect compile_fail
1654                         values {}
1655
1656                         vertex ""
1657                                 #version 300 es
1658                                 precision mediump float;
1659                                 in highp vec4 dEQP_Position;
1660
1661                                 invariant lowp centroid out float x0;
1662
1663                                  mediump out float x1;
1664
1665                                  highp uniform float x2;
1666
1667                                 void main()
1668                                 {
1669                                         x0 = 1.0;
1670                                         x1 = 2.0;
1671                                         gl_Position = dEQP_Position;
1672                                 }
1673                         ""
1674
1675                         fragment ""
1676                                 #version 300 es
1677                                 precision mediump float;
1678                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1679
1680                                  lowp centroid in float x0;
1681
1682                                  mediump in float x1;
1683
1684                                  highp uniform float x2;
1685
1686                                 void main()
1687                                 {
1688                                         float result = (x0 + x1 + x2) / 3.0;
1689                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1690                                 }
1691                         ""
1692                 end
1693                 case storage_invariant_precision
1694                         expect compile_fail
1695                         values {}
1696
1697                         vertex ""
1698                                 #version 300 es
1699                                 precision mediump float;
1700                                 in highp vec4 dEQP_Position;
1701
1702                                 centroid out invariant lowp float x0;
1703
1704                                 out mediump float x1;
1705
1706                                 uniform highp float x2;
1707
1708                                 void main()
1709                                 {
1710                                         x0 = 1.0;
1711                                         x1 = 2.0;
1712                                         gl_Position = dEQP_Position;
1713                                 }
1714                         ""
1715
1716                         fragment ""
1717                                 #version 300 es
1718                                 precision mediump float;
1719                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1720
1721                                 centroid in  lowp float x0;
1722
1723                                 in mediump float x1;
1724
1725                                 uniform highp float x2;
1726
1727                                 void main()
1728                                 {
1729                                         float result = (x0 + x1 + x2) / 3.0;
1730                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1731                                 }
1732                         ""
1733                 end
1734                 case storage_precision_invariant
1735                         expect compile_fail
1736                         values {}
1737
1738                         vertex ""
1739                                 #version 300 es
1740                                 precision mediump float;
1741                                 in highp vec4 dEQP_Position;
1742
1743                                 centroid out lowp invariant float x0;
1744
1745                                 out mediump float x1;
1746
1747                                 uniform highp float x2;
1748
1749                                 void main()
1750                                 {
1751                                         x0 = 1.0;
1752                                         x1 = 2.0;
1753                                         gl_Position = dEQP_Position;
1754                                 }
1755                         ""
1756
1757                         fragment ""
1758                                 #version 300 es
1759                                 precision mediump float;
1760                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1761
1762                                 centroid in lowp  float x0;
1763
1764                                 in mediump float x1;
1765
1766                                 uniform highp float x2;
1767
1768                                 void main()
1769                                 {
1770                                         float result = (x0 + x1 + x2) / 3.0;
1771                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1772                                 }
1773                         ""
1774                 end
1775                 case precision_invariant_storage
1776                         expect compile_fail
1777                         values {}
1778
1779                         vertex ""
1780                                 #version 300 es
1781                                 precision mediump float;
1782                                 in highp vec4 dEQP_Position;
1783
1784                                 lowp invariant centroid out float x0;
1785
1786                                 mediump out float x1;
1787
1788                                 highp uniform float x2;
1789
1790                                 void main()
1791                                 {
1792                                         x0 = 1.0;
1793                                         x1 = 2.0;
1794                                         gl_Position = dEQP_Position;
1795                                 }
1796                         ""
1797
1798                         fragment ""
1799                                 #version 300 es
1800                                 precision mediump float;
1801                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1802
1803                                 lowp  centroid in float x0;
1804
1805                                 mediump in float x1;
1806
1807                                 highp uniform float x2;
1808
1809                                 void main()
1810                                 {
1811                                         float result = (x0 + x1 + x2) / 3.0;
1812                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1813                                 }
1814                         ""
1815                 end
1816                 case precision_storage_invariant
1817                         expect compile_fail
1818                         values {}
1819
1820                         vertex ""
1821                                 #version 300 es
1822                                 precision mediump float;
1823                                 in highp vec4 dEQP_Position;
1824
1825                                 lowp centroid out invariant float x0;
1826
1827                                 mediump out float x1;
1828
1829                                 highp uniform float x2;
1830
1831                                 void main()
1832                                 {
1833                                         x0 = 1.0;
1834                                         x1 = 2.0;
1835                                         gl_Position = dEQP_Position;
1836                                 }
1837                         ""
1838
1839                         fragment ""
1840                                 #version 300 es
1841                                 precision mediump float;
1842                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1843
1844                                 lowp centroid in  float x0;
1845
1846                                 mediump in float x1;
1847
1848                                 highp uniform float x2;
1849
1850                                 void main()
1851                                 {
1852                                         float result = (x0 + x1 + x2) / 3.0;
1853                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1854                                 }
1855                         ""
1856                 end
1857                 case precision_storage
1858                         expect compile_fail
1859                         values {}
1860
1861                         vertex ""
1862                                 #version 300 es
1863                                 precision mediump float;
1864                                 in highp vec4 dEQP_Position;
1865
1866                                 lowp centroid out float x0;
1867
1868                                 mediump out float x1;
1869
1870                                 highp uniform float x2;
1871
1872                                 void main()
1873                                 {
1874                                         x0 = 1.0;
1875                                         x1 = 2.0;
1876                                         gl_Position = dEQP_Position;
1877                                 }
1878                         ""
1879
1880                         fragment ""
1881                                 #version 300 es
1882                                 precision mediump float;
1883                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1884
1885                                 lowp centroid in float x0;
1886
1887                                 mediump in float x1;
1888
1889                                 highp uniform float x2;
1890
1891                                 void main()
1892                                 {
1893                                         float result = (x0 + x1 + x2) / 3.0;
1894                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1895                                 }
1896                         ""
1897                 end
1898                 case storage_interp
1899                         expect compile_fail
1900                         values {}
1901
1902                         vertex ""
1903                                 #version 300 es
1904                                 precision mediump float;
1905                                 in highp vec4 dEQP_Position;
1906
1907                                 centroid out smooth float x0;
1908
1909                                 out flat float x1;
1910
1911                                 uniform float x2;
1912
1913                                 void main()
1914                                 {
1915                                         x0 = 1.0;
1916                                         x1 = 2.0;
1917                                         gl_Position = dEQP_Position;
1918                                 }
1919                         ""
1920
1921                         fragment ""
1922                                 #version 300 es
1923                                 precision mediump float;
1924                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1925
1926                                 centroid in smooth float x0;
1927
1928                                 in flat float x1;
1929
1930                                 uniform float x2;
1931
1932                                 void main()
1933                                 {
1934                                         float result = (x0 + x1 + x2) / 3.0;
1935                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1936                                 }
1937                         ""
1938                 end
1939                 case storage_invariant
1940                         expect compile_fail
1941                         values {}
1942
1943                         vertex ""
1944                                 #version 300 es
1945                                 precision mediump float;
1946                                 in highp vec4 dEQP_Position;
1947
1948                                 centroid out invariant float x0;
1949
1950                                 out float x1;
1951
1952                                 uniform float x2;
1953
1954                                 void main()
1955                                 {
1956                                         x0 = 1.0;
1957                                         x1 = 2.0;
1958                                         gl_Position = dEQP_Position;
1959                                 }
1960                         ""
1961
1962                         fragment ""
1963                                 #version 300 es
1964                                 precision mediump float;
1965                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
1966
1967                                 centroid in  float x0;
1968
1969                                 in float x1;
1970
1971                                 uniform float x2;
1972
1973                                 void main()
1974                                 {
1975                                         float result = (x0 + x1 + x2) / 3.0;
1976                                         dEQP_FragColor = vec4(result, result, result, 1.0);
1977                                 }
1978                         ""
1979                 end
1980                 case invariant_interp_storage_precision_invariant_input
1981                         expect compile_fail
1982                         values {}
1983
1984                         vertex ""
1985                                 #version 300 es
1986                                 precision mediump float;
1987                                 in highp vec4 dEQP_Position;
1988
1989                                 invariant smooth centroid out lowp float x0;
1990
1991                                  flat out mediump float x1;
1992
1993                                  uniform highp float x2;
1994
1995                                 void main()
1996                                 {
1997                                         x0 = 1.0;
1998                                         x1 = 2.0;
1999                                         gl_Position = dEQP_Position;
2000                                 }
2001                         ""
2002
2003                         fragment ""
2004                                 #version 300 es
2005                                 precision mediump float;
2006                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
2007
2008                                 invariant  smooth centroid in lowp float x0;
2009
2010                                  flat in mediump float x1;
2011
2012                                  uniform highp float x2;
2013
2014                                 void main()
2015                                 {
2016                                         float result = (x0 + x1 + x2) / 3.0;
2017                                         dEQP_FragColor = vec4(result, result, result, 1.0);
2018                                 }
2019                         ""
2020                 end
2021                 case interp_storage_precision_invariant_input
2022                         expect compile_fail
2023                         values {}
2024
2025                         vertex ""
2026                                 #version 300 es
2027                                 precision mediump float;
2028                                 in highp vec4 dEQP_Position;
2029
2030                                 smooth centroid out lowp float x0;
2031
2032                                 flat out mediump float x1;
2033
2034                                  uniform highp float x2;
2035
2036                                 void main()
2037                                 {
2038                                         x0 = 1.0;
2039                                         x1 = 2.0;
2040                                         gl_Position = dEQP_Position;
2041                                 }
2042                         ""
2043
2044                         fragment ""
2045                                 #version 300 es
2046                                 precision mediump float;
2047                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
2048
2049                                 invariant smooth centroid in lowp float x0;
2050
2051                                 flat in mediump float x1;
2052
2053                                  uniform highp float x2;
2054
2055                                 void main()
2056                                 {
2057                                         float result = (x0 + x1 + x2) / 3.0;
2058                                         dEQP_FragColor = vec4(result, result, result, 1.0);
2059                                 }
2060                         ""
2061                 end
2062                 case invariant_interp_storage_invariant_input
2063                         expect compile_fail
2064                         values {}
2065
2066                         vertex ""
2067                                 #version 300 es
2068                                 precision mediump float;
2069                                 in highp vec4 dEQP_Position;
2070
2071                                 invariant smooth centroid out float x0;
2072
2073                                  flat out float x1;
2074
2075                                  uniform float x2;
2076
2077                                 void main()
2078                                 {
2079                                         x0 = 1.0;
2080                                         x1 = 2.0;
2081                                         gl_Position = dEQP_Position;
2082                                 }
2083                         ""
2084
2085                         fragment ""
2086                                 #version 300 es
2087                                 precision mediump float;
2088                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
2089
2090                                 invariant  smooth centroid in float x0;
2091
2092                                  flat in float x1;
2093
2094                                  uniform float x2;
2095
2096                                 void main()
2097                                 {
2098                                         float result = (x0 + x1 + x2) / 3.0;
2099                                         dEQP_FragColor = vec4(result, result, result, 1.0);
2100                                 }
2101                         ""
2102                 end
2103                 case invariant_storage_precision_invariant_input
2104                         expect compile_fail
2105                         values {}
2106
2107                         vertex ""
2108                                 #version 300 es
2109                                 precision mediump float;
2110                                 in highp vec4 dEQP_Position;
2111
2112                                 invariant centroid out lowp float x0;
2113
2114                                  out mediump float x1;
2115
2116                                  uniform highp float x2;
2117
2118                                 void main()
2119                                 {
2120                                         x0 = 1.0;
2121                                         x1 = 2.0;
2122                                         gl_Position = dEQP_Position;
2123                                 }
2124                         ""
2125
2126                         fragment ""
2127                                 #version 300 es
2128                                 precision mediump float;
2129                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
2130
2131                                 invariant  centroid in lowp float x0;
2132
2133                                  in mediump float x1;
2134
2135                                  uniform highp float x2;
2136
2137                                 void main()
2138                                 {
2139                                         float result = (x0 + x1 + x2) / 3.0;
2140                                         dEQP_FragColor = vec4(result, result, result, 1.0);
2141                                 }
2142                         ""
2143                 end
2144                 case storage_precision_invariant_input
2145                         expect compile_fail
2146                         values {}
2147
2148                         vertex ""
2149                                 #version 300 es
2150                                 precision mediump float;
2151                                 in highp vec4 dEQP_Position;
2152
2153                                 centroid out lowp float x0;
2154
2155                                 out mediump float x1;
2156
2157                                 uniform highp float x2;
2158
2159                                 void main()
2160                                 {
2161                                         x0 = 1.0;
2162                                         x1 = 2.0;
2163                                         gl_Position = dEQP_Position;
2164                                 }
2165                         ""
2166
2167                         fragment ""
2168                                 #version 300 es
2169                                 precision mediump float;
2170                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
2171
2172                                 invariant centroid in lowp float x0;
2173
2174                                 in mediump float x1;
2175
2176                                 uniform highp float x2;
2177
2178                                 void main()
2179                                 {
2180                                         float result = (x0 + x1 + x2) / 3.0;
2181                                         dEQP_FragColor = vec4(result, result, result, 1.0);
2182                                 }
2183                         ""
2184                 end
2185                 case interp_storage_invariant_input
2186                         expect compile_fail
2187                         values {}
2188
2189                         vertex ""
2190                                 #version 300 es
2191                                 precision mediump float;
2192                                 in highp vec4 dEQP_Position;
2193
2194                                 smooth centroid out float x0;
2195
2196                                 flat out float x1;
2197
2198                                  uniform float x2;
2199
2200                                 void main()
2201                                 {
2202                                         x0 = 1.0;
2203                                         x1 = 2.0;
2204                                         gl_Position = dEQP_Position;
2205                                 }
2206                         ""
2207
2208                         fragment ""
2209                                 #version 300 es
2210                                 precision mediump float;
2211                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
2212
2213                                 invariant smooth centroid in float x0;
2214
2215                                 flat in float x1;
2216
2217                                  uniform float x2;
2218
2219                                 void main()
2220                                 {
2221                                         float result = (x0 + x1 + x2) / 3.0;
2222                                         dEQP_FragColor = vec4(result, result, result, 1.0);
2223                                 }
2224                         ""
2225                 end
2226                 case invariant_storage_invariant_input
2227                         expect compile_fail
2228                         values {}
2229
2230                         vertex ""
2231                                 #version 300 es
2232                                 precision mediump float;
2233                                 in highp vec4 dEQP_Position;
2234
2235                                 invariant centroid out float x0;
2236
2237                                  out float x1;
2238
2239                                  uniform float x2;
2240
2241                                 void main()
2242                                 {
2243                                         x0 = 1.0;
2244                                         x1 = 2.0;
2245                                         gl_Position = dEQP_Position;
2246                                 }
2247                         ""
2248
2249                         fragment ""
2250                                 #version 300 es
2251                                 precision mediump float;
2252                                 layout(location = 0) out mediump vec4 dEQP_FragColor;
2253
2254                                 invariant  centroid in float x0;
2255
2256                                  in float x1;
2257
2258                                  uniform float x2;
2259
2260                                 void main()
2261                                 {
2262                                         float result = (x0 + x1 + x2) / 3.0;
2263                                         dEQP_FragColor = vec4(result, result, result, 1.0);
2264                                 }
2265                         ""
2266                 end
2267
2268         end # invalid
2269
2270 end # variables
2271 group parameters "Order of qualification in function parameters."
2272
2273         group valid "Valid orderings."
2274
2275                 case storage_parameter_precision
2276                         expect pass
2277                         version 300 es
2278                         values {}
2279
2280                         both ""
2281                                 #version 300 es
2282                                 precision mediump float;
2283                                 ${DECLARATIONS}
2284
2285                                 float foo0 (const in lowp float x)
2286                                 {
2287                                         return x + 1.0;
2288                                 }
2289
2290                                 void foo1 ( out mediump float x)
2291                                 {
2292                                         x = 1.0;
2293                                 }
2294
2295                                 float foo2 ( inout highp float x)
2296                                 {
2297                                         return x + 1.0;
2298                                 }
2299
2300                                 void main()
2301                                 {
2302                                         ${SETUP}
2303                                         float result;
2304                                         foo1(result);
2305                                         float x0 = foo0(1.0);
2306                                         foo2(result);
2307                                         ${OUTPUT}
2308                                 }
2309                         ""
2310                 end
2311                 case storage_parameter
2312                         expect pass
2313                         version 300 es
2314                         values {}
2315
2316                         both ""
2317                                 #version 300 es
2318                                 precision mediump float;
2319                                 ${DECLARATIONS}
2320
2321                                 float foo0 (const in float x)
2322                                 {
2323                                         return x + 1.0;
2324                                 }
2325
2326                                 void foo1 ( out float x)
2327                                 {
2328                                         x = 1.0;
2329                                 }
2330
2331                                 float foo2 ( inout float x)
2332                                 {
2333                                         return x + 1.0;
2334                                 }
2335
2336                                 void main()
2337                                 {
2338                                         ${SETUP}
2339                                         float result;
2340                                         foo1(result);
2341                                         float x0 = foo0(1.0);
2342                                         foo2(result);
2343                                         ${OUTPUT}
2344                                 }
2345                         ""
2346                 end
2347                 case storage_precision
2348                         expect pass
2349                         version 300 es
2350                         values {}
2351
2352                         both ""
2353                                 #version 300 es
2354                                 precision mediump float;
2355                                 ${DECLARATIONS}
2356
2357                                 float foo0 (const lowp float x)
2358                                 {
2359                                         return x + 1.0;
2360                                 }
2361
2362                                 void foo1 ( mediump float x)
2363                                 {
2364                                         x = 1.0;
2365                                 }
2366
2367                                 float foo2 ( highp float x)
2368                                 {
2369                                         return x + 1.0;
2370                                 }
2371
2372                                 void main()
2373                                 {
2374                                         ${SETUP}
2375                                         float result;
2376                                         foo1(result);
2377                                         float x0 = foo0(1.0);
2378                                         foo2(result);
2379                                         ${OUTPUT}
2380                                 }
2381                         ""
2382                 end
2383                 case parameter_precision
2384                         expect pass
2385                         version 300 es
2386                         values {}
2387
2388                         both ""
2389                                 #version 300 es
2390                                 precision mediump float;
2391                                 ${DECLARATIONS}
2392
2393                                 float foo0 (in lowp float x)
2394                                 {
2395                                         return x + 1.0;
2396                                 }
2397
2398                                 void foo1 (out mediump float x)
2399                                 {
2400                                         x = 1.0;
2401                                 }
2402
2403                                 float foo2 (inout highp float x)
2404                                 {
2405                                         return x + 1.0;
2406                                 }
2407
2408                                 void main()
2409                                 {
2410                                         ${SETUP}
2411                                         float result;
2412                                         foo1(result);
2413                                         float x0 = foo0(1.0);
2414                                         foo2(result);
2415                                         ${OUTPUT}
2416                                 }
2417                         ""
2418                 end
2419
2420         end # valid
2421         group invalid "Invalid orderings."
2422
2423                 case storage_precision_parameter
2424                         expect compile_fail
2425                         version 300 es
2426                         values {}
2427
2428                         both ""
2429                                 #version 300 es
2430                                 precision mediump float;
2431                                 ${DECLARATIONS}
2432
2433                                 float foo0 (const lowp in float x)
2434                                 {
2435                                         return x + 1.0;
2436                                 }
2437
2438                                 void foo1 ( mediump out float x)
2439                                 {
2440                                         x = 1.0;
2441                                 }
2442
2443                                 float foo2 ( highp inout float x)
2444                                 {
2445                                         return x + 1.0;
2446                                 }
2447
2448                                 void main()
2449                                 {
2450                                         ${SETUP}
2451                                         float result;
2452                                         foo1(result);
2453                                         float x0 = foo0(1.0);
2454                                         foo2(result);
2455                                         ${OUTPUT}
2456                                 }
2457                         ""
2458                 end
2459                 case parameter_storage_precision
2460                         expect compile_fail
2461                         version 300 es
2462                         values {}
2463
2464                         both ""
2465                                 #version 300 es
2466                                 precision mediump float;
2467                                 ${DECLARATIONS}
2468
2469                                 float foo0 (in const lowp float x)
2470                                 {
2471                                         return x + 1.0;
2472                                 }
2473
2474                                 void foo1 (out mediump float x)
2475                                 {
2476                                         x = 1.0;
2477                                 }
2478
2479                                 float foo2 (inout highp float x)
2480                                 {
2481                                         return x + 1.0;
2482                                 }
2483
2484                                 void main()
2485                                 {
2486                                         ${SETUP}
2487                                         float result;
2488                                         foo1(result);
2489                                         float x0 = foo0(1.0);
2490                                         foo2(result);
2491                                         ${OUTPUT}
2492                                 }
2493                         ""
2494                 end
2495                 case parameter_precision_storage
2496                         expect compile_fail
2497                         version 300 es
2498                         values {}
2499
2500                         both ""
2501                                 #version 300 es
2502                                 precision mediump float;
2503                                 ${DECLARATIONS}
2504
2505                                 float foo0 (in lowp const float x)
2506                                 {
2507                                         return x + 1.0;
2508                                 }
2509
2510                                 void foo1 (out mediump float x)
2511                                 {
2512                                         x = 1.0;
2513                                 }
2514
2515                                 float foo2 (inout highp float x)
2516                                 {
2517                                         return x + 1.0;
2518                                 }
2519
2520                                 void main()
2521                                 {
2522                                         ${SETUP}
2523                                         float result;
2524                                         foo1(result);
2525                                         float x0 = foo0(1.0);
2526                                         foo2(result);
2527                                         ${OUTPUT}
2528                                 }
2529                         ""
2530                 end
2531                 case precision_storage_parameter
2532                         expect compile_fail
2533                         version 300 es
2534                         values {}
2535
2536                         both ""
2537                                 #version 300 es
2538                                 precision mediump float;
2539                                 ${DECLARATIONS}
2540
2541                                 float foo0 (lowp const in float x)
2542                                 {
2543                                         return x + 1.0;
2544                                 }
2545
2546                                 void foo1 (mediump out float x)
2547                                 {
2548                                         x = 1.0;
2549                                 }
2550
2551                                 float foo2 (highp inout float x)
2552                                 {
2553                                         return x + 1.0;
2554                                 }
2555
2556                                 void main()
2557                                 {
2558                                         ${SETUP}
2559                                         float result;
2560                                         foo1(result);
2561                                         float x0 = foo0(1.0);
2562                                         foo2(result);
2563                                         ${OUTPUT}
2564                                 }
2565                         ""
2566                 end
2567                 case precision_parameter_storage
2568                         expect compile_fail
2569                         version 300 es
2570                         values {}
2571
2572                         both ""
2573                                 #version 300 es
2574                                 precision mediump float;
2575                                 ${DECLARATIONS}
2576
2577                                 float foo0 (lowp in const float x)
2578                                 {
2579                                         return x + 1.0;
2580                                 }
2581
2582                                 void foo1 (mediump out float x)
2583                                 {
2584                                         x = 1.0;
2585                                 }
2586
2587                                 float foo2 (highp inout float x)
2588                                 {
2589                                         return x + 1.0;
2590                                 }
2591
2592                                 void main()
2593                                 {
2594                                         ${SETUP}
2595                                         float result;
2596                                         foo1(result);
2597                                         float x0 = foo0(1.0);
2598                                         foo2(result);
2599                                         ${OUTPUT}
2600                                 }
2601                         ""
2602                 end
2603                 case parameter_storage
2604                         expect compile_fail
2605                         version 300 es
2606                         values {}
2607
2608                         both ""
2609                                 #version 300 es
2610                                 precision mediump float;
2611                                 ${DECLARATIONS}
2612
2613                                 float foo0 (in const float x)
2614                                 {
2615                                         return x + 1.0;
2616                                 }
2617
2618                                 void foo1 (out float x)
2619                                 {
2620                                         x = 1.0;
2621                                 }
2622
2623                                 float foo2 (inout float x)
2624                                 {
2625                                         return x + 1.0;
2626                                 }
2627
2628                                 void main()
2629                                 {
2630                                         ${SETUP}
2631                                         float result;
2632                                         foo1(result);
2633                                         float x0 = foo0(1.0);
2634                                         foo2(result);
2635                                         ${OUTPUT}
2636                                 }
2637                         ""
2638                 end
2639                 case precision_storage
2640                         expect compile_fail
2641                         version 300 es
2642                         values {}
2643
2644                         both ""
2645                                 #version 300 es
2646                                 precision mediump float;
2647                                 ${DECLARATIONS}
2648
2649                                 float foo0 (lowp const float x)
2650                                 {
2651                                         return x + 1.0;
2652                                 }
2653
2654                                 void foo1 (mediump float x)
2655                                 {
2656                                         x = 1.0;
2657                                 }
2658
2659                                 float foo2 (highp float x)
2660                                 {
2661                                         return x + 1.0;
2662                                 }
2663
2664                                 void main()
2665                                 {
2666                                         ${SETUP}
2667                                         float result;
2668                                         foo1(result);
2669                                         float x0 = foo0(1.0);
2670                                         foo2(result);
2671                                         ${OUTPUT}
2672                                 }
2673                         ""
2674                 end
2675                 case precision_parameter
2676                         expect compile_fail
2677                         version 300 es
2678                         values {}
2679
2680                         both ""
2681                                 #version 300 es
2682                                 precision mediump float;
2683                                 ${DECLARATIONS}
2684
2685                                 float foo0 (lowp in float x)
2686                                 {
2687                                         return x + 1.0;
2688                                 }
2689
2690                                 void foo1 (mediump out float x)
2691                                 {
2692                                         x = 1.0;
2693                                 }
2694
2695                                 float foo2 (highp inout float x)
2696                                 {
2697                                         return x + 1.0;
2698                                 }
2699
2700                                 void main()
2701                                 {
2702                                         ${SETUP}
2703                                         float result;
2704                                         foo1(result);
2705                                         float x0 = foo0(1.0);
2706                                         foo2(result);
2707                                         ${OUTPUT}
2708                                 }
2709                         ""
2710                 end
2711
2712         end # invalid
2713
2714 end # parameters