src/third_party/angle/tests/angle_tests/GLSLTest.cpp

   1 #include "ANGLETest.h"
   2
   3 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
   4 typedef ::testing::Types<TFT<Gles::Two, Rend::D3D11>, TFT<Gles::Two, Rend::D3D9>> TestFixtureTypes;
   5 TYPED_TEST_CASE(GLSLTest, TestFixtureTypes);
   6
   7 template<typename T>
   8 class GLSLTest : public ANGLETest
   9 {
  10 protected:
  11     GLSLTest() : ANGLETest(T::GetGlesMajorVersion(), T::GetRequestedRenderer())
  12     {
  13         setWindowWidth(128);
  14         setWindowHeight(128);
  15         setConfigRedBits(8);
  16         setConfigGreenBits(8);
  17         setConfigBlueBits(8);
  18         setConfigAlphaBits(8);
  19     }
  20
  21     virtual void SetUp()
  22     {
  23         ANGLETest::SetUp();
  24
  25         mSimpleVSSource = SHADER_SOURCE
  26         (
  27             attribute vec4 inputAttribute;
  28             void main()
  29             {
  30                 gl_Position = inputAttribute;
  31             }
  32         );
  33     }
  34
  35     std::string GenerateVaryingType(GLint vectorSize)
  36     {
  37         char varyingType[10];
  38
  39         if (vectorSize == 1)
  40         {
  41             sprintf(varyingType, "float");
  42         }
  43         else
  44         {
  45             sprintf(varyingType, "vec%d", vectorSize);
  46         }
  47
  48         return std::string(varyingType);
  49     }
  50
  51     std::string GenerateVectorVaryingDeclaration(GLint vectorSize, GLint arraySize, GLint id)
  52     {
  53         char buff[100];
  54
  55         if (arraySize == 1)
  56         {
  57             sprintf(buff, "varying %s v%d;\n", GenerateVaryingType(vectorSize).c_str(), id);
  58         }
  59         else
  60         {
  61             sprintf(buff, "varying %s v%d[%d];\n", GenerateVaryingType(vectorSize).c_str(), id, arraySize);
  62         }
  63
  64         return std::string(buff);
  65     }
  66
  67     std::string GenerateVectorVaryingSettingCode(GLint vectorSize, GLint arraySize, GLint id)
  68     {
  69         std::string returnString;
  70         char buff[100];
  71
  72         if (arraySize == 1)
  73         {
  74             sprintf(buff, "\t v%d = %s(1.0);\n", id, GenerateVaryingType(vectorSize).c_str());
  75             returnString += buff;
  76         }
  77         else
  78         {
  79             for (int i = 0; i < arraySize; i++)
  80             {
  81                 sprintf(buff, "\t v%d[%d] = %s(1.0);\n", id, i, GenerateVaryingType(vectorSize).c_str());
  82                 returnString += buff;
  83             }
  84         }
  85
  86         return returnString;
  87     }
  88
  89     std::string GenerateVectorVaryingUseCode(GLint arraySize, GLint id)
  90     {
  91         if (arraySize == 1)
  92         {
  93             char buff[100];
  94             sprintf(buff, "v%d + ", id);
  95             return std::string(buff);
  96         }
  97         else
  98         {
  99             std::string returnString;
 100             for (int i = 0; i < arraySize; i++)
 101             {
 102                 char buff[100];
 103                 sprintf(buff, "v%d[%d] + ", id, i);
 104                 returnString += buff;
 105             }
 106             return returnString;
 107         }
 108     }
 109
 110     void GenerateGLSLWithVaryings(GLint floatCount, GLint floatArrayCount, GLint vec2Count, GLint vec2ArrayCount, GLint vec3Count, GLint vec3ArrayCount, std::string* fragmentShader, std::string* vertexShader)
 111     {
 112         // Generate a string declaring the varyings, to share between the fragment shader and the vertex shader.
 113         std::string varyingDeclaration;
 114
 115         unsigned int varyingCount = 0;
 116
 117         for (GLint i = 0; i < floatCount; i++)
 118         {
 119             varyingDeclaration += GenerateVectorVaryingDeclaration(1, 1, varyingCount);
 120             varyingCount += 1;
 121         }
 122
 123         for (GLint i = 0; i < floatArrayCount; i++)
 124         {
 125             varyingDeclaration += GenerateVectorVaryingDeclaration(1, 2, varyingCount);
 126             varyingCount += 1;
 127         }
 128
 129         for (GLint i = 0; i < vec2Count; i++)
 130         {
 131             varyingDeclaration += GenerateVectorVaryingDeclaration(2, 1, varyingCount);
 132             varyingCount += 1;
 133         }
 134
 135         for (GLint i = 0; i < vec2ArrayCount; i++)
 136         {
 137             varyingDeclaration += GenerateVectorVaryingDeclaration(2, 2, varyingCount);
 138             varyingCount += 1;
 139         }
 140
 141         for (GLint i = 0; i < vec3Count; i++)
 142         {
 143             varyingDeclaration += GenerateVectorVaryingDeclaration(3, 1, varyingCount);
 144             varyingCount += 1;
 145         }
 146
 147         for (GLint i = 0; i < vec3ArrayCount; i++)
 148         {
 149             varyingDeclaration += GenerateVectorVaryingDeclaration(3, 2, varyingCount);
 150             varyingCount += 1;
 151         }
 152
 153         // Generate the vertex shader
 154         vertexShader->clear();
 155         vertexShader->append(varyingDeclaration);
 156         vertexShader->append("\nvoid main()\n{\n");
 157
 158         unsigned int currentVSVarying = 0;
 159
 160         for (GLint i = 0; i < floatCount; i++)
 161         {
 162             vertexShader->append(GenerateVectorVaryingSettingCode(1, 1, currentVSVarying));
 163             currentVSVarying += 1;
 164         }
 165
 166         for (GLint i = 0; i < floatArrayCount; i++)
 167         {
 168             vertexShader->append(GenerateVectorVaryingSettingCode(1, 2, currentVSVarying));
 169             currentVSVarying += 1;
 170         }
 171
 172         for (GLint i = 0; i < vec2Count; i++)
 173         {
 174             vertexShader->append(GenerateVectorVaryingSettingCode(2, 1, currentVSVarying));
 175             currentVSVarying += 1;
 176         }
 177
 178         for (GLint i = 0; i < vec2ArrayCount; i++)
 179         {
 180             vertexShader->append(GenerateVectorVaryingSettingCode(2, 2, currentVSVarying));
 181             currentVSVarying += 1;
 182         }
 183
 184         for (GLint i = 0; i < vec3Count; i++)
 185         {
 186             vertexShader->append(GenerateVectorVaryingSettingCode(3, 1, currentVSVarying));
 187             currentVSVarying += 1;
 188         }
 189
 190         for (GLint i = 0; i < vec3ArrayCount; i++)
 191         {
 192             vertexShader->append(GenerateVectorVaryingSettingCode(3, 2, currentVSVarying));
 193             currentVSVarying += 1;
 194         }
 195
 196         vertexShader->append("}\n");
 197
 198         // Generate the fragment shader
 199         fragmentShader->clear();
 200         fragmentShader->append("precision highp float;\n");
 201         fragmentShader->append(varyingDeclaration);
 202         fragmentShader->append("\nvoid main() \n{ \n\tvec4 retColor = vec4(0,0,0,0);\n");
 203
 204         unsigned int currentFSVarying = 0;
 205
 206         // Make use of the float varyings
 207         fragmentShader->append("\tretColor += vec4(");
 208
 209         for (GLint i = 0; i < floatCount; i++)
 210         {
 211             fragmentShader->append(GenerateVectorVaryingUseCode(1, currentFSVarying));
 212             currentFSVarying += 1;
 213         }
 214
 215         for (GLint i = 0; i < floatArrayCount; i++)
 216         {
 217             fragmentShader->append(GenerateVectorVaryingUseCode(2, currentFSVarying));
 218             currentFSVarying += 1;
 219         }
 220
 221         fragmentShader->append("0.0, 0.0, 0.0, 0.0);\n");
 222
 223         // Make use of the vec2 varyings
 224         fragmentShader->append("\tretColor += vec4(");
 225
 226         for (GLint i = 0; i < vec2Count; i++)
 227         {
 228             fragmentShader->append(GenerateVectorVaryingUseCode(1, currentFSVarying));
 229             currentFSVarying += 1;
 230         }
 231
 232         for (GLint i = 0; i < vec2ArrayCount; i++)
 233         {
 234             fragmentShader->append(GenerateVectorVaryingUseCode(2, currentFSVarying));
 235             currentFSVarying += 1;
 236         }
 237
 238         fragmentShader->append("vec2(0.0, 0.0), 0.0, 0.0);\n");
 239
 240         // Make use of the vec3 varyings
 241         fragmentShader->append("\tretColor += vec4(");
 242
 243         for (GLint i = 0; i < vec3Count; i++)
 244         {
 245             fragmentShader->append(GenerateVectorVaryingUseCode(1, currentFSVarying));
 246             currentFSVarying += 1;
 247         }
 248
 249         for (GLint i = 0; i < vec3ArrayCount; i++)
 250         {
 251             fragmentShader->append(GenerateVectorVaryingUseCode(2, currentFSVarying));
 252             currentFSVarying += 1;
 253         }
 254
 255         fragmentShader->append("vec3(0.0, 0.0, 0.0), 0.0);\n");
 256         fragmentShader->append("\tgl_FragColor = retColor;\n}");
 257     }
 258
 259     std::string mSimpleVSSource;
 260 };
 261
 262 TYPED_TEST(GLSLTest, NamelessScopedStructs)
 263 {
 264     const std::string fragmentShaderSource = SHADER_SOURCE
 265     (
 266         precision mediump float;
 267
 268         void main()
 269         {
 270             struct
 271             {
 272                 float q;
 273             } b;
 274
 275             gl_FragColor = vec4(1, 0, 0, 1);
 276             gl_FragColor.a += b.q;
 277         }
 278     );
 279
 280     GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource);
 281     EXPECT_NE(0u, program);
 282 }
 283
 284 TYPED_TEST(GLSLTest, ScopedStructsOrderBug)
 285 {
 286     const std::string fragmentShaderSource = SHADER_SOURCE
 287     (
 288         precision mediump float;
 289
 290         struct T
 291         {
 292             float f;
 293         };
 294
 295         void main()
 296         {
 297             T a;
 298
 299             struct T
 300             {
 301                 float q;
 302             };
 303
 304             T b;
 305
 306             gl_FragColor = vec4(1, 0, 0, 1);
 307             gl_FragColor.a += a.f;
 308             gl_FragColor.a += b.q;
 309         }
 310     );
 311
 312     GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource);
 313     EXPECT_NE(0u, program);
 314 }
 315
 316 TYPED_TEST(GLSLTest, ScopedStructsBug)
 317 {
 318     const std::string fragmentShaderSource = SHADER_SOURCE
 319     (
 320         precision mediump float;
 321
 322         struct T_0
 323         {
 324             float f;
 325         };
 326
 327         void main()
 328         {
 329             gl_FragColor = vec4(1, 0, 0, 1);
 330
 331             struct T
 332             {
 333                 vec2 v;
 334             };
 335
 336             T_0 a;
 337             T b;
 338
 339             gl_FragColor.a += a.f;
 340             gl_FragColor.a += b.v.x;
 341         }
 342     );
 343
 344     GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource);
 345     EXPECT_NE(0u, program);
 346 }
 347
 348 TYPED_TEST(GLSLTest, DxPositionBug)
 349 {
 350     const std::string &vertexShaderSource = SHADER_SOURCE
 351     (
 352         attribute vec4 inputAttribute;
 353         varying float dx_Position;
 354         void main()
 355         {
 356             gl_Position = vec4(inputAttribute);
 357             dx_Position = 0.0;
 358         }
 359     );
 360
 361     const std::string &fragmentShaderSource = SHADER_SOURCE
 362     (
 363         precision mediump float;
 364
 365         varying float dx_Position;
 366
 367         void main()
 368         {
 369             gl_FragColor = vec4(dx_Position, 0, 0, 1);
 370         }
 371     );
 372
 373     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 374     EXPECT_NE(0u, program);
 375 }
 376
 377 TYPED_TEST(GLSLTest, ElseIfRewriting)
 378 {
 379     const std::string &vertexShaderSource =
 380         "attribute vec4 a_position;\n"
 381         "varying float v;\n"
 382         "void main() {\n"
 383         "  gl_Position = a_position;\n"
 384         "  v = 1.0;\n"
 385         "  if (a_position.x <= 0.5) {\n"
 386         "    v = 0.0;\n"
 387         "  } else if (a_position.x >= 0.5) {\n"
 388         "    v = 2.0;\n"
 389         "  }\n"
 390         "}\n";
 391
 392     const std::string &fragmentShaderSource =
 393         "precision highp float;\n"
 394         "varying float v;\n"
 395         "void main() {\n"
 396         "  vec4 color = vec4(1.0, 0.0, 0.0, 1.0);\n"
 397         "  if (v >= 1.0) color = vec4(0.0, 1.0, 0.0, 1.0);\n"
 398         "  if (v >= 2.0) color = vec4(0.0, 0.0, 1.0, 1.0);\n"
 399         "  gl_FragColor = color;\n"
 400         "}\n";
 401
 402     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 403     ASSERT_NE(0u, program);
 404
 405     drawQuad(program, "a_position", 0.5f);
 406     swapBuffers();
 407
 408     EXPECT_PIXEL_EQ(0, 0, 255, 0, 0, 255);
 409     EXPECT_PIXEL_EQ(getWindowWidth()-1, 0, 0, 255, 0, 255);
 410 }
 411
 412 TYPED_TEST(GLSLTest, TwoElseIfRewriting)
 413 {
 414     const std::string &vertexShaderSource =
 415         "attribute vec4 a_position;\n"
 416         "varying float v;\n"
 417         "void main() {\n"
 418         "  gl_Position = a_position;\n"
 419         "  if (a_position.x == 0.0) {\n"
 420         "    v = 1.0;\n"
 421         "  } else if (a_position.x > 0.5) {\n"
 422         "    v = 0.0;\n"
 423         "  } else if (a_position.x > 0.75) {\n"
 424         "    v = 0.5;\n"
 425         "  }\n"
 426         "}\n";
 427
 428     const std::string &fragmentShaderSource =
 429         "precision highp float;\n"
 430         "varying float v;\n"
 431         "void main() {\n"
 432         "  gl_FragColor = vec4(v, 0.0, 0.0, 1.0);\n"
 433         "}\n";
 434
 435     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 436     EXPECT_NE(0u, program);
 437 }
 438
 439 TYPED_TEST(GLSLTest, InvariantVaryingOut)
 440 {
 441     const std::string fragmentShaderSource = SHADER_SOURCE
 442     (
 443         precision mediump float;
 444         varying float v_varying;
 445         void main() { gl_FragColor = vec4(v_varying, 0, 0, 1.0); }
 446     );
 447
 448     const std::string vertexShaderSource = SHADER_SOURCE
 449     (
 450         attribute vec4 a_position;
 451         invariant varying float v_varying;
 452         void main() { v_varying = a_position.x; gl_Position = a_position; }
 453     );
 454
 455     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 456     EXPECT_NE(0u, program);
 457 }
 458
 459 TYPED_TEST(GLSLTest, FrontFacingAndVarying)
 460 {
 461     const std::string vertexShaderSource = SHADER_SOURCE
 462     (
 463         attribute vec4 a_position;
 464         varying float v_varying;
 465         void main()
 466         {
 467             v_varying = a_position.x;
 468             gl_Position = a_position;
 469         }
 470     );
 471
 472     const std::string fragmentShaderSource = SHADER_SOURCE
 473     (
 474         precision mediump float;
 475         varying float v_varying;
 476         void main()
 477         {
 478             vec4 c;
 479
 480             if (gl_FrontFacing)
 481             {
 482                 c = vec4(v_varying, 0, 0, 1.0);
 483             }
 484             else
 485             {
 486                 c = vec4(0, v_varying, 0, 1.0);
 487             }
 488             gl_FragColor = c;
 489         }
 490     );
 491
 492     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 493     EXPECT_NE(0u, program);
 494 }
 495
 496 TYPED_TEST(GLSLTest, InvariantVaryingIn)
 497 {
 498     const std::string fragmentShaderSource = SHADER_SOURCE
 499     (
 500         precision mediump float;
 501         invariant varying float v_varying;
 502         void main() { gl_FragColor = vec4(v_varying, 0, 0, 1.0); }
 503     );
 504
 505     const std::string vertexShaderSource = SHADER_SOURCE
 506     (
 507         attribute vec4 a_position;
 508         varying float v_varying;
 509         void main() { v_varying = a_position.x; gl_Position = a_position; }
 510     );
 511
 512     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 513     EXPECT_NE(0u, program);
 514 }
 515
 516 TYPED_TEST(GLSLTest, InvariantVaryingBoth)
 517 {
 518     const std::string fragmentShaderSource = SHADER_SOURCE
 519     (
 520         precision mediump float;
 521         invariant varying float v_varying;
 522         void main() { gl_FragColor = vec4(v_varying, 0, 0, 1.0); }
 523     );
 524
 525     const std::string vertexShaderSource = SHADER_SOURCE
 526     (
 527         attribute vec4 a_position;
 528         invariant varying float v_varying;
 529         void main() { v_varying = a_position.x; gl_Position = a_position; }
 530     );
 531
 532     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 533     EXPECT_NE(0u, program);
 534 }
 535
 536 TYPED_TEST(GLSLTest, InvariantGLPosition)
 537 {
 538     const std::string fragmentShaderSource = SHADER_SOURCE
 539     (
 540         precision mediump float;
 541         varying float v_varying;
 542         void main() { gl_FragColor = vec4(v_varying, 0, 0, 1.0); }
 543     );
 544
 545     const std::string vertexShaderSource = SHADER_SOURCE
 546     (
 547         attribute vec4 a_position;
 548         invariant gl_Position;
 549         varying float v_varying;
 550         void main() { v_varying = a_position.x; gl_Position = a_position; }
 551     );
 552
 553     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 554     EXPECT_NE(0u, program);
 555 }
 556
 557 TYPED_TEST(GLSLTest, InvariantAll)
 558 {
 559     const std::string fragmentShaderSource = SHADER_SOURCE
 560     (
 561         precision mediump float;
 562         varying float v_varying;
 563         void main() { gl_FragColor = vec4(v_varying, 0, 0, 1.0); }
 564     );
 565
 566     const std::string vertexShaderSource =
 567         "#pragma STDGL invariant(all)\n"
 568         "attribute vec4 a_position;\n"
 569         "varying float v_varying;\n"
 570         "void main() { v_varying = a_position.x; gl_Position = a_position; }\n";
 571
 572     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 573     EXPECT_NE(0u, program);
 574 }
 575
 576 TYPED_TEST(GLSLTest, MaxVaryingVec3)
 577 {
 578     GLint maxVaryings = 0;
 579     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 580
 581     std::string fragmentShaderSource;
 582     std::string vertexShaderSource;
 583
 584     GenerateGLSLWithVaryings(0, 0, 0, 0, maxVaryings, 0, &fragmentShaderSource, &vertexShaderSource);
 585
 586     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 587     EXPECT_NE(0u, program);
 588 }
 589
 590 TYPED_TEST(GLSLTest, MaxVaryingVec3Array)
 591 {
 592     GLint maxVaryings = 0;
 593     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 594
 595     std::string fragmentShaderSource;
 596     std::string vertexShaderSource;
 597
 598     GenerateGLSLWithVaryings(0, 0, 0, 0, 0, maxVaryings / 2, &fragmentShaderSource, &vertexShaderSource);
 599
 600     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 601     EXPECT_NE(0u, program);
 602 }
 603
 604 // Disabled because of a failure in D3D9
 605 TYPED_TEST(GLSLTest, DISABLED_MaxVaryingVec3AndOneFloat)
 606 {
 607     GLint maxVaryings = 0;
 608     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 609
 610     std::string fragmentShaderSource;
 611     std::string vertexShaderSource;
 612
 613     GenerateGLSLWithVaryings(1, 0, 0, 0, maxVaryings, 0, &fragmentShaderSource, &vertexShaderSource);
 614
 615     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 616     EXPECT_NE(0u, program);
 617 }
 618
 619 // Disabled because of a failure in D3D9
 620 TYPED_TEST(GLSLTest, DISABLED_MaxVaryingVec3ArrayAndOneFloatArray)
 621 {
 622     GLint maxVaryings = 0;
 623     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 624
 625     std::string fragmentShaderSource;
 626     std::string vertexShaderSource;
 627
 628     GenerateGLSLWithVaryings(0, 1, 0, 0, 0, maxVaryings / 2, &fragmentShaderSource, &vertexShaderSource);
 629
 630     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 631     EXPECT_NE(0u, program);
 632 }
 633
 634 // Disabled because of a failure in D3D9
 635 TYPED_TEST(GLSLTest, DISABLED_TwiceMaxVaryingVec2)
 636 {
 637     GLint maxVaryings = 0;
 638     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 639
 640     std::string fragmentShaderSource;
 641     std::string vertexShaderSource;
 642
 643     GenerateGLSLWithVaryings(0, 0, 2 * maxVaryings, 0, 0, 0, &fragmentShaderSource, &vertexShaderSource);
 644
 645     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 646     EXPECT_NE(0u, program);
 647 }
 648
 649 // Disabled because of a failure in D3D9
 650 TYPED_TEST(GLSLTest, DISABLED_MaxVaryingVec2Arrays)
 651 {
 652     GLint maxVaryings = 0;
 653     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 654
 655     std::string fragmentShaderSource;
 656     std::string vertexShaderSource;
 657
 658     GenerateGLSLWithVaryings(0, 0, 0, maxVaryings, 0, 0, &fragmentShaderSource, &vertexShaderSource);
 659
 660     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 661     EXPECT_NE(0u, program);
 662 }
 663
 664 TYPED_TEST(GLSLTest, MaxPlusOneVaryingVec3)
 665 {
 666     GLint maxVaryings = 0;
 667     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 668
 669     std::string fragmentShaderSource;
 670     std::string vertexShaderSource;
 671
 672     GenerateGLSLWithVaryings(0, 0, 0, 0, maxVaryings + 1, 0, &fragmentShaderSource, &vertexShaderSource);
 673
 674     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 675     EXPECT_EQ(0u, program);
 676 }
 677
 678 TYPED_TEST(GLSLTest, MaxPlusOneVaryingVec3Array)
 679 {
 680     GLint maxVaryings = 0;
 681     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 682
 683     std::string fragmentShaderSource;
 684     std::string vertexShaderSource;
 685
 686     GenerateGLSLWithVaryings(0, 0, 0, 0, 0, maxVaryings / 2 + 1, &fragmentShaderSource, &vertexShaderSource);
 687
 688     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 689     EXPECT_EQ(0u, program);
 690 }
 691
 692 TYPED_TEST(GLSLTest, MaxVaryingVec3AndOneVec2)
 693 {
 694     GLint maxVaryings = 0;
 695     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 696
 697     std::string fragmentShaderSource;
 698     std::string vertexShaderSource;
 699
 700     GenerateGLSLWithVaryings(0, 0, 1, 0, maxVaryings, 0, &fragmentShaderSource, &vertexShaderSource);
 701
 702     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 703     EXPECT_EQ(0u, program);
 704 }
 705
 706 TYPED_TEST(GLSLTest, MaxPlusOneVaryingVec2)
 707 {
 708     GLint maxVaryings = 0;
 709     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 710
 711     std::string fragmentShaderSource;
 712     std::string vertexShaderSource;
 713
 714     GenerateGLSLWithVaryings(0, 0, 2 * maxVaryings + 1, 0, 0, 0, &fragmentShaderSource, &vertexShaderSource);
 715
 716     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 717     EXPECT_EQ(0u, program);
 718 }
 719
 720 TYPED_TEST(GLSLTest, MaxVaryingVec3ArrayAndMaxPlusOneFloatArray)
 721 {
 722     GLint maxVaryings = 0;
 723     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 724
 725     std::string fragmentShaderSource;
 726     std::string vertexShaderSource;
 727
 728     GenerateGLSLWithVaryings(0, maxVaryings / 2 + 1, 0, 0, 0, maxVaryings / 2, &fragmentShaderSource, &vertexShaderSource);
 729
 730     GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
 731     EXPECT_EQ(0u, program);
 732 }